Remove all unnecessary allocations (as flagged by lint)

30 files changed, 298 insertions, 303 deletions

diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index e9f15c0a8f5..5b08f59b35c 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -107,7 +107,7 @@ pub struct Ctx {
 pub type vt = visit::vt<@mut Ctx>;
 
 pub fn extend(cx: @mut Ctx, elt: ident) -> @path {
-    @(vec::append(copy cx.path, ~[path_name(elt)]))
+    @(vec::append(copy cx.path, [path_name(elt)]))
 }
 
 pub fn mk_ast_map_visitor() -> vt {
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index eaacb054ca1..e209fd14b5e 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -21,7 +21,7 @@ use core::to_bytes;
 
 pub fn path_name_i(idents: &[ident], intr: @token::ident_interner) -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
-    str::connect(idents.map(|i| copy *intr.get(*i)), ~"::")
+    str::connect(idents.map(|i| copy *intr.get(*i)), "::")
 }
 
 
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index aebe5bbfc74..981df1156df 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -291,7 +291,7 @@ pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: &str) ->
  * linkage
  */
 pub fn find_linkage_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] {
-    do find_attrs_by_name(attrs, ~"link").flat_map |attr| {
+    do find_attrs_by_name(attrs, "link").flat_map |attr| {
         match attr.node.value.node {
             ast::meta_list(_, ref items) => /* FIXME (#2543) */ copy *items,
             _ => ~[]
@@ -314,9 +314,9 @@ pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr {
         match attr.node.value.node {
           ast::meta_word(@~"inline") => ia_hint,
           ast::meta_list(@~"inline", ref items) => {
-            if !find_meta_items_by_name(*items, ~"always").is_empty() {
+            if !find_meta_items_by_name(*items, "always").is_empty() {
                 ia_always
-            } else if !find_meta_items_by_name(*items, ~"never").is_empty() {
+            } else if !find_meta_items_by_name(*items, "never").is_empty() {
                 ia_never
             } else {
                 ia_hint
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 993fa612a27..21e2ad82b14 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -218,7 +218,7 @@ pub fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
         print_macro_backtrace(cm, sp);
       }
       None => {
-        print_diagnostic(~"", lvl, msg);
+        print_diagnostic("", lvl, msg);
       }
     }
 }
@@ -296,7 +296,7 @@ fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
         print_diagnostic(*ss, note,
                          fmt!("in expansion of %s!", ei.callee.name));
         let ss = cm.span_to_str(ei.call_site);
-        print_diagnostic(ss, note, ~"expansion site");
+        print_diagnostic(ss, note, "expansion site");
         print_macro_backtrace(cm, ei.call_site);
     }
 }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index a97c69ba4ff..2a7f8c8865b 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -250,7 +250,7 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg)
         fn call_site(&self) -> span {
             match *self.backtrace {
                 Some(@ExpandedFrom(CallInfo {call_site: cs, _})) => cs,
-                None => self.bug(~"missing top span")
+                None => self.bug("missing top span")
             }
         }
         fn print_backtrace(&self) { }
@@ -276,7 +276,7 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg)
               })) => {
                 *self.backtrace = prev
               }
-              _ => self.bug(~"tried to pop without a push")
+              _ => self.bug("tried to pop without a push")
             }
         }
         fn span_fatal(&self, sp: span, msg: &str) -> ! {
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 96e5e414322..da32cc11625 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -21,15 +21,13 @@ pub fn expand_syntax_ext(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree])
         if i & 1 == 1 {
             match *e {
                 ast::tt_tok(_, token::COMMA) => (),
-                _ => cx.span_fatal(sp, ~"concat_idents! \
-                                         expecting comma.")
+                _ => cx.span_fatal(sp, "concat_idents! expecting comma.")
             }
         } else {
             match *e {
                 ast::tt_tok(_, token::IDENT(ident,_)) =>
                 res_str += cx.str_of(ident),
-                _ => cx.span_fatal(sp, ~"concat_idents! \
-                                         requires ident args.")
+                _ => cx.span_fatal(sp, "concat_idents! requires ident args.")
             }
         }
     }
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index 2e2f382a768..fe205112046 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -291,7 +291,7 @@ fn expand_deriving_decodable_struct_method(
             unnamed_field => {
                 cx.span_unimpl(
                     span,
-                    ~"unnamed fields with `deriving(Decodable)`"
+                    "unnamed fields with `deriving(Decodable)`"
                 );
             }
         }
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 8a1c3933f51..b1df8405d76 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -321,7 +321,7 @@ fn expand_deriving_encodable_struct_method(
             unnamed_field => {
                 cx.span_unimpl(
                     span,
-                    ~"unnamed fields with `deriving(Encodable)`"
+                    "unnamed fields with `deriving(Encodable)`"
                 );
             }
         }
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index fc14e3c3f73..2fc9dadfe2c 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -539,8 +539,8 @@ impl<'self> MethodDef<'self> {
                     (opt_id, field, other_fields)
                 }
             }
-            [] => { cx.span_bug(span, ~"No self arguments to non-static \
-                                        method in generic `deriving`") }
+            [] => { cx.span_bug(span, "No self arguments to non-static \
+                                       method in generic `deriving`") }
         };
 
         // body of the inner most destructuring match
@@ -658,8 +658,8 @@ impl<'self> MethodDef<'self> {
             // we've matched against all arguments, so make the final
             // expression at the bottom of the match tree
             if matches_so_far.len() == 0 {
-                cx.span_bug(span, ~"no self match on an enum in generic \
-                                    `deriving`");
+                cx.span_bug(span, "no self match on an enum in generic \
+                                   `deriving`");
             }
             // we currently have a vec of vecs, where each
             // subvec is the fields of one of the arguments,
@@ -718,8 +718,8 @@ impl<'self> MethodDef<'self> {
                 // make a matching-variant match, and a _ match.
                 let index = match matching {
                     Some(i) => i,
-                    None => cx.span_bug(span, ~"Non-matching variants when required to \
-                                                be matching in generic `deriving`")
+                    None => cx.span_bug(span, "Non-matching variants when required to \
+                                               be matching in generic `deriving`")
                 };
 
                 // matching-variant match
diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs
index 78cd5cdb423..6f4429af12d 100644
--- a/src/libsyntax/ext/deriving/mod.rs
+++ b/src/libsyntax/ext/deriving/mod.rs
@@ -67,11 +67,11 @@ pub fn expand_meta_deriving(cx: @ext_ctxt,
 
     match mitem.node {
         meta_name_value(_, ref l) => {
-            cx.span_err(l.span, ~"unexpected value in `deriving`");
+            cx.span_err(l.span, "unexpected value in `deriving`");
             in_items
         }
         meta_word(_) | meta_list(_, []) => {
-            cx.span_warn(mitem.span, ~"empty trait list in `deriving`");
+            cx.span_warn(mitem.span, "empty trait list in `deriving`");
             in_items
         }
         meta_list(_, ref titems) => {
diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs
index 13cb09e970d..f155cb3790f 100644
--- a/src/libsyntax/ext/deriving/to_str.rs
+++ b/src/libsyntax/ext/deriving/to_str.rs
@@ -49,6 +49,6 @@ fn to_str_substructure(cx: @ext_ctxt, span: span, substr: &Substructure) -> @exp
                                     cx.ident_of("log_str")],
                                   ~[self_addr])
         }
-        _ => cx.span_bug(span, ~"Invalid number of arguments in `deriving(ToStr)`")
+        _ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`")
     }
 }
diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs
index 8fd372e4792..5fc3aeb789c 100644
--- a/src/libsyntax/ext/deriving/ty.rs
+++ b/src/libsyntax/ext/deriving/ty.rs
@@ -167,8 +167,8 @@ pub impl Ty {
             Literal(ref p) => {
                 p.to_path(cx, span, self_ty, self_generics)
             }
-            Ptr(*) => { cx.span_bug(span, ~"Pointer in a path in generic `deriving`") }
-            Tuple(*) => { cx.span_bug(span, ~"Tuple in a path in generic `deriving`") }
+            Ptr(*) => { cx.span_bug(span, "Pointer in a path in generic `deriving`") }
+            Tuple(*) => { cx.span_bug(span, "Tuple in a path in generic `deriving`") }
         }
     }
 }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index db95cb65b76..ff0cf6f28ad 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -234,7 +234,7 @@ pub fn expand_item_mac(extsbox: @mut SyntaxEnv,
         item_mac(codemap::spanned { node: mac_invoc_tt(pth, ref tts), _}) => {
             (pth, copy *tts)
         }
-        _ => cx.span_bug(it.span, ~"invalid item macro invocation")
+        _ => cx.span_bug(it.span, "invalid item macro invocation")
     };
 
     let extname = cx.parse_sess().interner.get(pth.idents[0]);
@@ -377,8 +377,7 @@ pub fn expand_block(extsbox: @mut SyntaxEnv,
             // see note below about treatment of exts table
             with_exts_frame!(extsbox,orig(blk,sp,fld))
         },
-        _ => cx.span_bug(sp,
-                         ~"expected ScopeMacros binding for \" block\"")
+        _ => cx.span_bug(sp, "expected ScopeMacros binding for \" block\"")
     }
 }
 
@@ -628,7 +627,7 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess,
                                               attrs,
                                               parse_sess) {
         Some(item) => item,
-        None => cx.bug(~"expected core macros to parse correctly")
+        None => cx.bug("expected core macros to parse correctly")
     };
     // This is run for its side-effects on the expander env,
     // as it registers all the core macros as expanders.
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 26b3178a911..24046faa684 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -88,7 +88,7 @@ fn pieces_to_expr(cx: @ext_ctxt, sp: span,
                 let count_is_args = ~[count_lit];
                 return mk_call_global(cx, sp, count_is_path, count_is_args);
               }
-              _ => cx.span_unimpl(sp, ~"unimplemented fmt! conversion")
+              _ => cx.span_unimpl(sp, "unimplemented fmt! conversion")
             }
         }
         fn make_ty(cx: @ext_ctxt, sp: span, t: Ty) -> @ast::expr {
diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs
index 8799bd064f6..104e5f94d17 100644
--- a/src/libsyntax/ext/pipes/liveness.rs
+++ b/src/libsyntax/ext/pipes/liveness.rs
@@ -85,7 +85,7 @@ pub fn analyze(proto: @mut protocol_, _cx: @ext_ctxt) {
     }
 
     if self_live.len() > 0 {
-        let states = str::connect(self_live.map(|s| copy s.name), ~" ");
+        let states = str::connect(self_live.map(|s| copy s.name), " ");
 
         debug!("protocol %s is unbounded due to loops involving: %s",
                copy proto.name, states);
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index 5c99ddc9040..28c8c9a704d 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -114,7 +114,7 @@ impl proto_parser for parser::Parser {
             self.bump();
             None
           }
-          _ => self.fatal(~"invalid next state")
+          _ => self.fatal("invalid next state")
         };
 
         state.add_message(mname, *self.span, args, next);
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index b537ef87d54..8a9c714e7e9 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -96,7 +96,7 @@ impl gen_send for message {
                          name,
                          str::connect(vec::append_one(
                            arg_names.map(|x| cx.str_of(*x)),
-                             ~"s"), ~", "));
+                             ~"s"), ", "));
 
             if !try {
                 body += fmt!("::core::pipes::send(pipe, message);\n");
@@ -148,7 +148,7 @@ impl gen_send for message {
                 }
                 else {
                     ~"(" + str::connect(arg_names.map(|x| copy *x),
-                                        ~", ") + ~")"
+                                        ", ") + ~")"
                 };
 
                 let mut body = ~"{ ";
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index fc673c4422f..2134c2ba19b 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -86,7 +86,7 @@ pub mod rt {
 
     impl<'self> ToSource for &'self [@ast::item] {
         fn to_source(&self, cx: @ext_ctxt) -> ~str {
-            str::connect(self.map(|i| i.to_source(cx)), ~"\n\n")
+            str::connect(self.map(|i| i.to_source(cx)), "\n\n")
         }
     }
 
@@ -98,7 +98,7 @@ pub mod rt {
 
     impl<'self> ToSource for &'self [@ast::Ty] {
         fn to_source(&self, cx: @ext_ctxt) -> ~str {
-            str::connect(self.map(|i| i.to_source(cx)), ~", ")
+            str::connect(self.map(|i| i.to_source(cx)), ", ")
         }
     }
 
@@ -421,7 +421,7 @@ fn id_ext(cx: @ext_ctxt, str: &str) -> ast::ident {
 
 // Lift an ident to the expr that evaluates to that ident.
 fn mk_ident(cx: @ext_ctxt, sp: span, ident: ast::ident) -> @ast::expr {
-    let e_str = build::mk_uniq_str(cx, sp, cx.str_of(ident));
+    let e_str = build::mk_base_str(cx, sp, cx.str_of(ident));
     build::mk_method_call(cx, sp,
                           build::mk_path(cx, sp, ids_ext(cx, ~[~"ext_cx"])),
                           id_ext(cx, "ident_of"),
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index ab22b3152f4..c0d9b3f06af 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -67,7 +67,7 @@ pub fn expand_mod(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree])
     base::check_zero_tts(cx, sp, tts, "module_path!");
     base::MRExpr(mk_base_str(cx, sp,
                               str::connect(cx.mod_path().map(
-                                  |x| cx.str_of(*x)), ~"::")))
+                                  |x| cx.str_of(*x)), "::")))
 }
 
 // include! : parse the given file as an expr
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index 1bb40808142..0ecb3b2a3f4 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -39,7 +39,7 @@ pub fn expand_trace_macros(cx: @ext_ctxt,
     } else if rust_parser.is_keyword("false") {
         cx.set_trace_macros(false);
     } else {
-        cx.span_fatal(sp, ~"trace_macros! only accepts `true` or `false`")
+        cx.span_fatal(sp, "trace_macros! only accepts `true` or `false`")
     }
 
     rust_parser.bump();
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index aa211973f1c..a34045a883e 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -371,7 +371,7 @@ pub fn parse(
                              *sess.interner.get(bind))
                       }
                       _ => fail!()
-                    } }), ~" or ");
+                    } }), " or ");
                 return error(sp, fmt!(
                     "Local ambiguity: multiple parsing options: \
                      built-in NTs %s or %u other options.",
@@ -413,7 +413,7 @@ pub fn parse_nt(p: &Parser, name: &str) -> nonterminal {
     match name {
       "item" => match p.parse_item(~[]) {
         Some(i) => token::nt_item(i),
-        None => p.fatal(~"expected an item keyword")
+        None => p.fatal("expected an item keyword")
       },
       "block" => token::nt_block(p.parse_block()),
       "stmt" => token::nt_stmt(p.parse_stmt(~[])),
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index be6cc7a846a..d34eca342e9 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -64,12 +64,12 @@ pub fn add_new_extension(cx: @ext_ctxt,
     // Extract the arguments:
     let lhses = match *argument_map.get(&lhs_nm) {
         @matched_seq(ref s, _) => /* FIXME (#2543) */ @copy *s,
-        _ => cx.span_bug(sp, ~"wrong-structured lhs")
+        _ => cx.span_bug(sp, "wrong-structured lhs")
     };
 
     let rhses = match *argument_map.get(&rhs_nm) {
       @matched_seq(ref s, _) => /* FIXME (#2543) */ @copy *s,
-      _ => cx.span_bug(sp, ~"wrong-structured rhs")
+      _ => cx.span_bug(sp, "wrong-structured rhs")
     };
 
     // Given `lhses` and `rhses`, this is the new macro we create
@@ -114,10 +114,10 @@ pub fn add_new_extension(cx: @ext_ctxt,
                                     (*tts).slice(1u,(*tts).len()-1u).to_owned()
                                 }
                                 _ => cx.span_fatal(
-                                    sp, ~"macro rhs must be delimited")
+                                    sp, "macro rhs must be delimited")
                             }
                         },
-                        _ => cx.span_bug(sp, ~"bad thing in rhs")
+                        _ => cx.span_bug(sp, "bad thing in rhs")
                     };
                     // rhs has holes ( `$id` and `$(...)` that need filled)
                     let trncbr = new_tt_reader(s_d, itr, Some(named_matches),
@@ -139,7 +139,7 @@ pub fn add_new_extension(cx: @ext_ctxt,
                   error(sp, ref msg) => cx.span_fatal(sp, (*msg))
                 }
               }
-              _ => cx.bug(~"non-matcher found in parsed lhses")
+              _ => cx.bug("non-matcher found in parsed lhses")
             }
         }
         cx.span_fatal(best_fail_spot, best_fail_msg);
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 438efb2326c..d806801b7d1 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -234,9 +234,9 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
               lis_unconstrained => {
                 r.sp_diag.span_fatal(
                     sp, /* blame macro writer */
-                      ~"attempted to repeat an expression \
-                        containing no syntax \
-                        variables matched as repeating at this depth");
+                      "attempted to repeat an expression \
+                       containing no syntax \
+                       variables matched as repeating at this depth");
                   }
                   lis_contradiction(ref msg) => {
                       /* FIXME #2887 blame macro invoker instead*/
@@ -247,8 +247,8 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                       if !zerok {
                         r.sp_diag.span_fatal(sp, /* FIXME #2887 blame invoker
                         */
-                                             ~"this must repeat at least \
-                                               once");
+                                             "this must repeat at least \
+                                              once");
                           }
 
                     r.stack.idx += 1u;
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index 93584b00d39..d947fa43ca7 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -51,7 +51,7 @@ impl parser_attr for Parser {
                     self.span.hi
                 );
                 if attr.node.style != ast::attr_outer {
-                  self.fatal(~"expected outer comment");
+                  self.fatal("expected outer comment");
                 }
                 attrs += ~[attr];
                 self.bump();
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 89873b27935..da7ad6ffeff 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -33,15 +33,15 @@ pub struct cmnt {
 }
 
 pub fn is_doc_comment(s: &str) -> bool {
-    (s.starts_with(~"///") && !is_line_non_doc_comment(s)) ||
-    s.starts_with(~"//!") ||
-    (s.starts_with(~"/**") && !is_block_non_doc_comment(s)) ||
-    s.starts_with(~"/*!")
+    (s.starts_with("///") && !is_line_non_doc_comment(s)) ||
+    s.starts_with("//!") ||
+    (s.starts_with("/**") && !is_block_non_doc_comment(s)) ||
+    s.starts_with("/*!")
 }
 
 pub fn doc_comment_style(comment: &str) -> ast::attr_style {
     assert!(is_doc_comment(comment));
-    if comment.starts_with(~"//!") || comment.starts_with(~"/*!") {
+    if comment.starts_with("//!") || comment.starts_with("/*!") {
         ast::attr_inner
     } else {
         ast::attr_outer
@@ -92,14 +92,14 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
         };
     }
 
-    if comment.starts_with(~"//") {
+    if comment.starts_with("//") {
         // FIXME #5475:
         // return comment.slice(3u, comment.len()).trim().to_owned();
         let r = comment.slice(3u, comment.len()); return r.trim().to_owned();
 
     }
 
-    if comment.starts_with(~"/*") {
+    if comment.starts_with("/*") {
         let mut lines = ~[];
         for str::each_line_any(comment.slice(3u, comment.len() - 2u)) |line| {
             lines.push(line.to_owned())
@@ -108,7 +108,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
         let lines = block_trim(lines, ~"\t ", None);
         let lines = block_trim(lines, ~"*", Some(1u));
         let lines = block_trim(lines, ~"\t ", None);
-        return str::connect(lines, ~"\n");
+        return str::connect(lines, "\n");
     }
 
     fail!("not a doc-comment: %s", comment);
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index 6595343654f..6e85b814b31 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -104,9 +104,7 @@ pub impl Parser {
                 i
             }
             token::INTERPOLATED(token::nt_ident(*)) => {
-                self.bug(
-                    ~"ident interpolation not converted to real token"
-                );
+                self.bug("ident interpolation not converted to real token");
             }
             _ => {
                 self.fatal(
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index fddeea93024..2de27285ce2 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -354,7 +354,7 @@ pub impl Parser {
     fn get_lifetime(&self, tok: &token::Token) -> ast::ident {
         match *tok {
             token::LIFETIME(ref ident) => copy *ident,
-            _ => self.bug(~"not a lifetime"),
+            _ => self.bug("not a lifetime"),
         }
     }
 
@@ -434,7 +434,7 @@ pub impl Parser {
         });
 
         fn parse_onceness(this: &Parser) -> Onceness {
-            if this.eat_keyword(~"once") {
+            if this.eat_keyword("once") {
                 Once
             } else {
                 Many
@@ -1354,7 +1354,7 @@ pub impl Parser {
                 self.bump();
                 match *self.token {
                     token::LPAREN | token::LBRACE => {}
-                    _ => self.fatal(~"expected open delimiter")
+                    _ => self.fatal("expected open delimiter")
                 };
 
                 let ket = token::flip_delimiter(&*self.token);
@@ -1520,7 +1520,7 @@ pub impl Parser {
                 self.bump();
                 (Some(sep), zerok)
             } else {
-                self.fatal(~"expected `*` or `+`");
+                self.fatal("expected `*` or `+`");
             }
         }
     }
@@ -1587,7 +1587,7 @@ pub impl Parser {
 
         match *self.token {
             token::EOF => {
-                self.fatal(~"file ended with unbalanced delimiters");
+                self.fatal("file ended with unbalanced delimiters");
             }
             token::LPAREN | token::LBRACE | token::LBRACKET => {
                 let close_delim = token::flip_delimiter(&*self.token);
@@ -1602,7 +1602,7 @@ pub impl Parser {
                                 |p| p.parse_token_tree()
                             ),
                             // the close delimiter:
-                            ~[parse_any_tt_tok(self)]
+                            [parse_any_tt_tok(self)]
                         )
                     )
                 )
@@ -1635,7 +1635,7 @@ pub impl Parser {
                     token::flip_delimiter(self.token)
                 )
             }
-            _ => self.fatal(~"expected open delimiter")
+            _ => self.fatal("expected open delimiter")
         }
     }
 
@@ -1678,7 +1678,7 @@ pub impl Parser {
                     token::RPAREN
                 );
                 if ms.len() == 0u {
-                    self.fatal(~"repetition body must be nonempty");
+                    self.fatal("repetition body must be nonempty");
                 }
                 let (sep, zerok) = self.parse_sep_and_zerok();
                 match_seq(ms, sep, zerok, name_idx_lo, *name_idx)
@@ -1996,7 +1996,7 @@ pub impl Parser {
                 let block = self.parse_lambda_block_expr();
                 let last_arg = self.mk_expr(block.span.lo, block.span.hi,
                                             ctor(block));
-                let args = vec::append(args, ~[last_arg]);
+                let args = vec::append(args, [last_arg]);
                 self.mk_expr(lo.lo, block.span.hi, expr_call(f, args, sugar))
             }
             expr_method_call(f, i, /*bad*/ copy tps,
@@ -2004,7 +2004,7 @@ pub impl Parser {
                 let block = self.parse_lambda_block_expr();
                 let last_arg = self.mk_expr(block.span.lo, block.span.hi,
                                             ctor(block));
-                let args = vec::append(args, ~[last_arg]);
+                let args = vec::append(args, [last_arg]);
                 self.mk_expr(lo.lo, block.span.hi,
                              expr_method_call(f, i, tps, args, sugar))
             }
@@ -2575,7 +2575,7 @@ pub impl Parser {
             // XXX: Remove after snapshot.
         }
         if !is_plain_ident(&*self.token) {
-            self.fatal(~"expected ident");
+            self.fatal("expected ident");
         }
         let name = self.parse_ident();
         self.expect(&token::COLON);
@@ -2597,7 +2597,7 @@ pub impl Parser {
             // If we have attributes then we should have an item
             if !current_attrs.is_empty() {
                 p.span_err(*p.last_span,
-                           ~"expected item after attributes");
+                           "expected item after attributes");
             }
         }
 
@@ -2664,7 +2664,7 @@ pub impl Parser {
                                     "view items must be declared at the top of the block");
                 }
                 iovi_foreign_item(_) => {
-                    self.fatal(~"foreign items are not allowed here");
+                    self.fatal("foreign items are not allowed here");
                 }
                 iovi_none() => { /* fallthrough */ }
             }
@@ -3528,7 +3528,7 @@ pub impl Parser {
 
         if first && attrs_remaining_len > 0u {
             // We parsed attributes for the first item but didn't find it
-            self.span_err(*self.last_span,~"expected item after attributes");
+            self.span_err(*self.last_span, "expected item after attributes");
         }
 
         ast::_mod { view_items: view_items, items: items }
@@ -3583,7 +3583,7 @@ pub impl Parser {
                 let (main_mod, new_mod) =
                     match (main_mod_item, new_mod_item) {
                     (item_mod(m), item_mod(n)) => (m, n),
-                    _ => self.bug(~"parsed mod item should be mod")
+                    _ => self.bug("parsed mod item should be mod")
                 };
                 let merged_mod = ast::_mod {
                     view_items: main_mod.view_items + new_mod.view_items,
@@ -3600,7 +3600,7 @@ pub impl Parser {
     fn push_mod_path(&self, id: ident, attrs: ~[ast::attribute]) {
         let default_path = self.sess.interner.get(id);
         let file_path = match ::attr::first_attr_value_str_by_name(
-            attrs, ~"path") {
+            attrs, "path") {
 
             Some(d) => copy *d,
             None => copy *default_path
@@ -3623,7 +3623,7 @@ pub impl Parser {
         let mod_path = Path(".").push_many(*mod_path_stack);
         let default_path = *self.sess.interner.get(id) + ~".rs";
         let file_path = match ::attr::first_attr_value_str_by_name(
-            outer_attrs, ~"path") {
+            outer_attrs, "path") {
             Some(d) => {
                 let path = Path(copy *d);
                 if !path.is_absolute {
@@ -3660,7 +3660,7 @@ pub impl Parser {
         return (ast::item_mod(m0), mod_attrs);
 
         fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str {
-            match ::attr::first_attr_value_str_by_name(attrs, ~"path") {
+            match ::attr::first_attr_value_str_by_name(attrs, "path") {
                 Some(d) => copy *d,
                 None => default
             }
@@ -3915,7 +3915,7 @@ pub impl Parser {
         }
         self.expect(&token::RBRACE);
         if (have_disr && !all_nullary) {
-            self.fatal(~"discriminator values can only be used with a c-like \
+            self.fatal("discriminator values can only be used with a c-like \
                         enum");
         }
 
@@ -4209,7 +4209,7 @@ pub impl Parser {
                     || self.look_ahead(2) == token::LBRACE) {
             // MACRO INVOCATION ITEM
             if attrs.len() > 0 {
-                self.fatal(~"attrs on macros are not yet supported");
+                self.fatal("attrs on macros are not yet supported");
             }
 
             // item macro.
@@ -4235,7 +4235,7 @@ pub impl Parser {
                         |p| p.parse_token_tree()
                     )
                 }
-                _ => self.fatal(~"expected open delimiter")
+                _ => self.fatal("expected open delimiter")
             };
             // single-variant-enum... :
             let m = ast::mac_invoc_tt(pth, tts);
@@ -4262,9 +4262,9 @@ pub impl Parser {
             iovi_none =>
                 None,
             iovi_view_item(_) =>
-                self.fatal(~"view items are not allowed here"),
+                self.fatal("view items are not allowed here"),
             iovi_foreign_item(_) =>
-                self.fatal(~"foreign items are not allowed here"),
+                self.fatal("foreign items are not allowed here"),
             iovi_item(item) =>
                 Some(item)
         }
@@ -4404,7 +4404,7 @@ pub impl Parser {
             let metadata = self.parse_optional_meta();
             view_item_extern_mod(ident, metadata, self.get_id())
         } else {
-            self.bug(~"expected view item");
+            self.bug("expected view item");
         };
         self.expect(&token::SEMI);
         @ast::view_item { node: node,
@@ -4551,7 +4551,7 @@ pub impl Parser {
                 self.bump();
                 self.id_to_str(s)
             }
-            _ =>  self.fatal(~"expected string literal")
+            _ =>  self.fatal("expected string literal")
         }
     }
 }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index b4bad5abbf9..055336a6d95 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -173,14 +173,14 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str {
       LIT_INT_UNSUFFIXED(i) => { i.to_str() }
       LIT_FLOAT(s, t) => {
         let mut body = copy *in.get(s);
-        if body.ends_with(~".") {
+        if body.ends_with(".") {
             body = body + ~"0";  // `10.f` is not a float literal
         }
         body + ast_util::float_ty_to_str(t)
       }
       LIT_FLOAT_UNSUFFIXED(s) => {
         let mut body = copy *in.get(s);
-        if body.ends_with(~".") {
+        if body.ends_with(".") {
             body = body + ~"0";  // `10.f` is not a float literal
         }
         body
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 52495522613..6b2ee61545e 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -437,7 +437,7 @@ pub impl Printer {
     }
     fn print_newline(&mut self, amount: int) {
         debug!("NEWLINE %d", amount);
-        (*self.out).write_str(~"\n");
+        (*self.out).write_str("\n");
         self.pending_indentation = 0;
         self.indent(amount);
     }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index b2db752af11..a535e5d195f 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -227,17 +227,17 @@ pub fn box(s: @ps, u: uint, b: pp::breaks) {
     pp::box(s.s, u, b);
 }
 
-pub fn nbsp(s: @ps) { word(s.s, ~" "); }
+pub fn nbsp(s: @ps) { word(s.s, " "); }
 
 pub fn word_nbsp(s: @ps, w: &str) { word(s.s, w); nbsp(s); }
 
 pub fn word_space(s: @ps, w: &str) { word(s.s, w); space(s.s); }
 
-pub fn popen(s: @ps) { word(s.s, ~"("); }
+pub fn popen(s: @ps) { word(s.s, "("); }
 
-pub fn pclose(s: @ps) { word(s.s, ~")"); }
+pub fn pclose(s: @ps) { word(s.s, ")"); }
 
-pub fn head(s: @ps, w: ~str) {
+pub fn head(s: @ps, w: &str) {
     // outer-box is consistent
     cbox(s, indent_unit);
     // head-box is inconsistent
@@ -249,7 +249,7 @@ pub fn head(s: @ps, w: ~str) {
 }
 
 pub fn bopen(s: @ps) {
-    word(s.s, ~"{");
+    word(s.s, "{");
     end(s); // close the head-box
 }
 
@@ -260,7 +260,7 @@ pub fn bclose_maybe_open (s: @ps, span: codemap::span, indented: uint,
                           close_box: bool) {
     maybe_print_comment(s, span.hi);
     break_offset_if_not_bol(s, 1u, -(indented as int));
-    word(s.s, ~"}");
+    word(s.s, "}");
     if close_box {
         end(s); // close the outer-box
     }
@@ -304,18 +304,18 @@ pub fn break_offset_if_not_bol(s: @ps, n: uint, off: int) {
 // Synthesizes a comment that was not textually present in the original source
 // file.
 pub fn synth_comment(s: @ps, text: ~str) {
-    word(s.s, ~"/*");
+    word(s.s, "/*");
     space(s.s);
     word(s.s, text);
     space(s.s);
-    word(s.s, ~"*/");
+    word(s.s, "*/");
 }
 
 pub fn commasep<IN: Copy>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN)) {
     box(s, 0u, b);
     let mut first = true;
     for elts.each |elt| {
-        if first { first = false; } else { word_space(s, ~","); }
+        if first { first = false; } else { word_space(s, ","); }
         op(s, *elt);
     }
     end(s);
@@ -332,7 +332,7 @@ pub fn commasep_cmnt<IN: Copy>(s: @ps, b: breaks, elts: &[IN], op: &fn(@ps, IN),
         op(s, *elt);
         i += 1u;
         if i < len {
-            word(s.s, ~",");
+            word(s.s, ",");
             maybe_print_trailing_comment(s, get_span(*elt),
                                          Some(get_span(elts[i]).hi));
             space_if_not_bol(s);
@@ -374,23 +374,23 @@ pub fn print_type(s: @ps, ty: @ast::Ty) {
     maybe_print_comment(s, ty.span.lo);
     ibox(s, 0u);
     match ty.node {
-      ast::ty_nil => word(s.s, ~"()"),
-      ast::ty_bot => word(s.s, ~"!"),
-      ast::ty_box(ref mt) => { word(s.s, ~"@"); print_mt(s, mt); }
-      ast::ty_uniq(ref mt) => { word(s.s, ~"~"); print_mt(s, mt); }
+      ast::ty_nil => word(s.s, "()"),
+      ast::ty_bot => word(s.s, "!"),
+      ast::ty_box(ref mt) => { word(s.s, "@"); print_mt(s, mt); }
+      ast::ty_uniq(ref mt) => { word(s.s, "~"); print_mt(s, mt); }
       ast::ty_vec(ref mt) => {
-        word(s.s, ~"[");
+        word(s.s, "[");
         match mt.mutbl {
-          ast::m_mutbl => word_space(s, ~"mut"),
-          ast::m_const => word_space(s, ~"const"),
+          ast::m_mutbl => word_space(s, "mut"),
+          ast::m_const => word_space(s, "const"),
           ast::m_imm => ()
         }
         print_type(s, mt.ty);
-        word(s.s, ~"]");
+        word(s.s, "]");
       }
-      ast::ty_ptr(ref mt) => { word(s.s, ~"*"); print_mt(s, mt); }
+      ast::ty_ptr(ref mt) => { word(s.s, "*"); print_mt(s, mt); }
       ast::ty_rptr(lifetime, ref mt) => {
-          word(s.s, ~"&");
+          word(s.s, "&");
           print_opt_lifetime(s, lifetime);
           print_mt(s, mt);
       }
@@ -398,7 +398,7 @@ pub fn print_type(s: @ps, ty: @ast::Ty) {
         popen(s);
         commasep(s, inconsistent, *elts, print_type);
         if elts.len() == 1 {
-            word(s.s, ~",");
+            word(s.s, ",");
         }
         pclose(s);
       }
@@ -418,16 +418,16 @@ pub fn print_type(s: @ps, ty: @ast::Ty) {
       }
       ast::ty_path(path, _) => print_path(s, path, false),
       ast::ty_fixed_length_vec(ref mt, v) => {
-        word(s.s, ~"[");
+        word(s.s, "[");
         match mt.mutbl {
-            ast::m_mutbl => word_space(s, ~"mut"),
-            ast::m_const => word_space(s, ~"const"),
+            ast::m_mutbl => word_space(s, "mut"),
+            ast::m_const => word_space(s, "const"),
             ast::m_imm => ()
         }
         print_type(s, mt.ty);
-        word(s.s, ~", ..");
+        word(s.s, ", ..");
         print_expr(s, v);
-        word(s.s, ~"]");
+        word(s.s, "]");
       }
       ast::ty_mac(_) => {
           fail!("print_type doesn't know how to print a ty_mac");
@@ -449,15 +449,15 @@ pub fn print_foreign_item(s: @ps, item: @ast::foreign_item) {
         print_fn(s, decl, Some(purity), AbiSet::Rust(), item.ident, generics, None,
                  ast::inherited);
         end(s); // end head-ibox
-        word(s.s, ~";");
+        word(s.s, ";");
         end(s); // end the outer fn box
       }
       ast::foreign_item_const(t) => {
-        head(s, ~"static");
+        head(s, "static");
         print_ident(s, item.ident);
-        word_space(s, ~":");
+        word_space(s, ":");
         print_type(s, t);
-        word(s.s, ~";");
+        word(s.s, ";");
         end(s); // end the head-ibox
         end(s); // end the outer cbox
       }
@@ -474,14 +474,14 @@ pub fn print_item(s: @ps, item: @ast::item) {
       ast::item_const(ty, expr) => {
         head(s, visibility_qualified(item.vis, ~"static"));
         print_ident(s, item.ident);
-        word_space(s, ~":");
+        word_space(s, ":");
         print_type(s, ty);
         space(s.s);
         end(s); // end the head-ibox
 
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_expr(s, expr);
-        word(s.s, ~";");
+        word(s.s, ";");
         end(s); // end the outer cbox
 
       }
@@ -496,7 +496,7 @@ pub fn print_item(s: @ps, item: @ast::item) {
             None,
             item.vis
         );
-        word(s.s, ~" ");
+        word(s.s, " ");
         print_block_with_attrs(s, body, item.attrs);
       }
       ast::item_mod(ref _mod) => {
@@ -512,7 +512,7 @@ pub fn print_item(s: @ps, item: @ast::item) {
         word_nbsp(s, nmod.abis.to_str());
         match nmod.sort {
             ast::named => {
-                word_nbsp(s, ~"mod");
+                word_nbsp(s, "mod");
                 print_ident(s, item.ident);
                 nbsp(s);
             }
@@ -531,9 +531,9 @@ pub fn print_item(s: @ps, item: @ast::item) {
         end(s); // end the inner ibox
 
         space(s.s);
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_type(s, ty);
-        word(s.s, ~";");
+        word(s.s, ";");
         end(s); // end the outer ibox
       }
       ast::item_enum(ref enum_definition, ref params) => {
@@ -562,7 +562,7 @@ pub fn print_item(s: @ps, item: @ast::item) {
             Some(t) => {
                 print_trait_ref(s, t);
                 space(s.s);
-                word_space(s, ~"for");
+                word_space(s, "for");
             }
             None => ()
         };
@@ -571,7 +571,7 @@ pub fn print_item(s: @ps, item: @ast::item) {
         space(s.s);
 
         if methods.len() == 0 {
-            word(s.s, ~";");
+            word(s.s, ";");
         } else {
             bopen(s);
             for methods.each |meth| {
@@ -585,16 +585,16 @@ pub fn print_item(s: @ps, item: @ast::item) {
         print_ident(s, item.ident);
         print_generics(s, generics);
         if traits.len() != 0u {
-            word(s.s, ~":");
+            word(s.s, ":");
             for traits.eachi |i, trait_| {
                 nbsp(s);
                 if i != 0 {
-                    word_space(s, ~"+");
+                    word_space(s, "+");
                 }
                 print_path(s, trait_.path, false);
             }
         }
-        word(s.s, ~" ");
+        word(s.s, " ");
         bopen(s);
         for methods.each |meth| {
             print_trait_method(s, meth);
@@ -605,7 +605,7 @@ pub fn print_item(s: @ps, item: @ast::item) {
                                    _}) => {
         print_visibility(s, item.vis);
         print_path(s, pth, false);
-        word(s.s, ~"! ");
+        word(s.s, "! ");
         print_ident(s, item.ident);
         cbox(s, indent_unit);
         popen(s);
@@ -641,7 +641,7 @@ pub fn print_variants(s: @ps,
         print_outer_attributes(s, v.node.attrs);
         ibox(s, indent_unit);
         print_variant(s, v);
-        word(s.s, ~",");
+        word(s.s, ",");
         end(s);
         maybe_print_trailing_comment(s, v.span, None);
     }
@@ -692,7 +692,7 @@ pub fn print_struct(s: @ps,
             }
             pclose(s);
         }
-        word(s.s, ~";");
+        word(s.s, ";");
         end(s);
         end(s); // close the outer-box
     } else {
@@ -709,9 +709,9 @@ pub fn print_struct(s: @ps,
                     print_outer_attributes(s, field.node.attrs);
                     print_visibility(s, visibility);
                     print_ident(s, ident);
-                    word_nbsp(s, ~":");
+                    word_nbsp(s, ":");
                     print_type(s, field.node.ty);
-                    word(s.s, ~",");
+                    word(s.s, ",");
                 }
             }
         }
@@ -734,17 +734,17 @@ pub fn print_tt(s: @ps, tt: &ast::token_tree) {
           word(s.s, parse::token::to_str(s.intr, tk));
       }
       ast::tt_seq(_, ref tts, ref sep, zerok) => {
-        word(s.s, ~"$(");
+        word(s.s, "$(");
         for (*tts).each() |tt_elt| { print_tt(s, tt_elt); }
-        word(s.s, ~")");
+        word(s.s, ")");
         match (*sep) {
           Some(ref tk) => word(s.s, parse::token::to_str(s.intr, tk)),
           None => ()
         }
-        word(s.s, if zerok { ~"*" } else { ~"+" });
+        word(s.s, if zerok { "*" } else { "+" });
       }
       ast::tt_nonterminal(_, name) => {
-        word(s.s, ~"$");
+        word(s.s, "$");
         print_ident(s, name);
       }
     }
@@ -776,7 +776,7 @@ pub fn print_variant(s: @ps, v: &ast::variant) {
             }
         }
         ast::struct_variant_kind(struct_def) => {
-            head(s, ~"");
+            head(s, "");
             let generics = ast_util::empty_generics();
             print_struct(s, struct_def, &generics, v.node.name, v.span);
         }
@@ -784,7 +784,7 @@ pub fn print_variant(s: @ps, v: &ast::variant) {
     match v.node.disr_expr {
       Some(d) => {
         space(s.s);
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_expr(s, d);
       }
       _ => ()
@@ -798,7 +798,7 @@ pub fn print_ty_method(s: @ps, m: &ast::ty_method) {
     print_ty_fn(s, None, None, None, m.purity, ast::Many,
                 &m.decl, Some(m.ident), Some(&m.generics),
                 Some(/*bad*/ copy m.explicit_self.node));
-    word(s.s, ~";");
+    word(s.s, ";");
 }
 
 pub fn print_trait_method(s: @ps, m: &ast::trait_method) {
@@ -815,7 +815,7 @@ pub fn print_method(s: @ps, meth: @ast::method) {
     print_fn(s, &meth.decl, Some(meth.purity), AbiSet::Rust(),
              meth.ident, &meth.generics, Some(meth.explicit_self.node),
              meth.vis);
-    word(s.s, ~" ");
+    word(s.s, " ");
     print_block_with_attrs(s, &meth.body, meth.attrs);
 }
 
@@ -837,7 +837,7 @@ pub fn print_inner_attributes(s: @ps, attrs: &[ast::attribute]) {
           ast::attr_inner => {
             print_attribute(s, *attr);
             if !attr.node.is_sugared_doc {
-                word(s.s, ~";");
+                word(s.s, ";");
             }
             count += 1;
           }
@@ -855,9 +855,9 @@ pub fn print_attribute(s: @ps, attr: ast::attribute) {
         let comment = attr::get_meta_item_value_str(meta).get();
         word(s.s, *comment);
     } else {
-        word(s.s, ~"#[");
+        word(s.s, "#[");
         print_meta_item(s, attr.node.value);
-        word(s.s, ~"]");
+        word(s.s, "]");
     }
 }
 
@@ -875,15 +875,15 @@ pub fn print_stmt(s: @ps, st: &ast::stmt) {
       ast::stmt_semi(expr, _) => {
         space_if_not_bol(s);
         print_expr(s, expr);
-        word(s.s, ~";");
+        word(s.s, ";");
       }
       ast::stmt_mac(ref mac, semi) => {
         space_if_not_bol(s);
         print_mac(s, mac);
-        if semi { word(s.s, ~";"); }
+        if semi { word(s.s, ";"); }
       }
     }
-    if parse::classify::stmt_ends_with_semi(st) { word(s.s, ~";"); }
+    if parse::classify::stmt_ends_with_semi(st) { word(s.s, ";"); }
     maybe_print_trailing_comment(s, st.span, None);
 }
 
@@ -925,7 +925,7 @@ pub fn print_possibly_embedded_block_(s: @ps,
                                       attrs: &[ast::attribute],
                                       close_box: bool) {
     match blk.node.rules {
-      ast::unsafe_blk => word_space(s, ~"unsafe"),
+      ast::unsafe_blk => word_space(s, "unsafe"),
       ast::default_blk => ()
     }
     maybe_print_comment(s, blk.span.lo);
@@ -956,8 +956,8 @@ pub fn print_possibly_embedded_block_(s: @ps,
 
 pub fn print_if(s: @ps, test: @ast::expr, blk: &ast::blk,
                 elseopt: Option<@ast::expr>, chk: bool) {
-    head(s, ~"if");
-    if chk { word_nbsp(s, ~"check"); }
+    head(s, "if");
+    if chk { word_nbsp(s, "check"); }
     print_expr(s, test);
     space(s.s);
     print_block(s, blk);
@@ -969,7 +969,7 @@ pub fn print_if(s: @ps, test: @ast::expr, blk: &ast::blk,
               ast::expr_if(i, ref t, e) => {
                 cbox(s, indent_unit - 1u);
                 ibox(s, 0u);
-                word(s.s, ~" else if ");
+                word(s.s, " else if ");
                 print_expr(s, i);
                 space(s.s);
                 print_block(s, t);
@@ -979,7 +979,7 @@ pub fn print_if(s: @ps, test: @ast::expr, blk: &ast::blk,
               ast::expr_block(ref b) => {
                 cbox(s, indent_unit - 1u);
                 ibox(s, 0u);
-                word(s.s, ~" else ");
+                word(s.s, " else ");
                 print_block(s, b);
               }
               // BLEAH, constraints would be great here
@@ -998,7 +998,7 @@ pub fn print_mac(s: @ps, m: &ast::mac) {
     match m.node {
       ast::mac_invoc_tt(pth, ref tts) => {
         print_path(s, pth, false);
-        word(s.s, ~"!");
+        word(s.s, "!");
         popen(s);
         print_tts(s, *tts);
         pclose(s);
@@ -1009,11 +1009,11 @@ pub fn print_mac(s: @ps, m: &ast::mac) {
 pub fn print_vstore(s: @ps, t: ast::vstore) {
     match t {
         ast::vstore_fixed(Some(i)) => word(s.s, fmt!("%u", i)),
-        ast::vstore_fixed(None) => word(s.s, ~"_"),
-        ast::vstore_uniq => word(s.s, ~"~"),
-        ast::vstore_box => word(s.s, ~"@"),
+        ast::vstore_fixed(None) => word(s.s, "_"),
+        ast::vstore_uniq => word(s.s, "~"),
+        ast::vstore_box => word(s.s, "@"),
         ast::vstore_slice(r) => {
-            word(s.s, ~"&");
+            word(s.s, "&");
             print_opt_lifetime(s, r);
         }
     }
@@ -1021,16 +1021,16 @@ pub fn print_vstore(s: @ps, t: ast::vstore) {
 
 pub fn print_expr_vstore(s: @ps, t: ast::expr_vstore) {
     match t {
-      ast::expr_vstore_uniq => word(s.s, ~"~"),
-      ast::expr_vstore_box => word(s.s, ~"@"),
+      ast::expr_vstore_uniq => word(s.s, "~"),
+      ast::expr_vstore_box => word(s.s, "@"),
       ast::expr_vstore_mut_box => {
-        word(s.s, ~"@");
-        word(s.s, ~"mut");
+        word(s.s, "@");
+        word(s.s, "mut");
       }
-      ast::expr_vstore_slice => word(s.s, ~"&"),
+      ast::expr_vstore_slice => word(s.s, "&"),
       ast::expr_vstore_mut_slice => {
-        word(s.s, ~"&");
-        word(s.s, ~"mut");
+        word(s.s, "&");
+        word(s.s, "mut");
       }
     }
 }
@@ -1041,11 +1041,11 @@ pub fn print_call_pre(s: @ps,
                    -> Option<@ast::expr> {
     match sugar {
         ast::DoSugar => {
-            head(s, ~"do");
+            head(s, "do");
             Some(base_args.pop())
         }
         ast::ForSugar => {
-            head(s, ~"for");
+            head(s, "for");
             Some(base_args.pop())
         }
         ast::NoSugar => None
@@ -1082,9 +1082,9 @@ pub fn print_call_post(s: @ps,
 pub fn print_expr(s: @ps, expr: @ast::expr) {
     fn print_field(s: @ps, field: ast::field) {
         ibox(s, indent_unit);
-        if field.node.mutbl == ast::m_mutbl { word_nbsp(s, ~"mut"); }
+        if field.node.mutbl == ast::m_mutbl { word_nbsp(s, "mut"); }
         print_ident(s, field.node.ident);
-        word_space(s, ~":");
+        word_space(s, ":");
         print_expr(s, field.node.expr);
         end(s);
     }
@@ -1101,53 +1101,53 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
         },
       ast::expr_vec(ref exprs, mutbl) => {
         ibox(s, indent_unit);
-        word(s.s, ~"[");
+        word(s.s, "[");
         if mutbl == ast::m_mutbl {
-            word(s.s, ~"mut");
+            word(s.s, "mut");
             if exprs.len() > 0u { nbsp(s); }
         }
         commasep_exprs(s, inconsistent, *exprs);
-        word(s.s, ~"]");
+        word(s.s, "]");
         end(s);
       }
 
       ast::expr_repeat(element, count, mutbl) => {
         ibox(s, indent_unit);
-        word(s.s, ~"[");
+        word(s.s, "[");
         if mutbl == ast::m_mutbl {
-            word(s.s, ~"mut");
+            word(s.s, "mut");
             nbsp(s);
         }
         print_expr(s, element);
-        word(s.s, ~",");
-        word(s.s, ~"..");
+        word(s.s, ",");
+        word(s.s, "..");
         print_expr(s, count);
-        word(s.s, ~"]");
+        word(s.s, "]");
         end(s);
       }
 
       ast::expr_struct(path, ref fields, wth) => {
         print_path(s, path, true);
-        word(s.s, ~"{");
+        word(s.s, "{");
         commasep_cmnt(s, consistent, (*fields), print_field, get_span);
         match wth {
             Some(expr) => {
                 ibox(s, indent_unit);
-                word(s.s, ~",");
+                word(s.s, ",");
                 space(s.s);
-                word(s.s, ~"..");
+                word(s.s, "..");
                 print_expr(s, expr);
                 end(s);
             }
-            _ => (word(s.s, ~","))
+            _ => (word(s.s, ","))
         }
-        word(s.s, ~"}");
+        word(s.s, "}");
       }
       ast::expr_tup(ref exprs) => {
         popen(s);
         commasep_exprs(s, inconsistent, *exprs);
         if exprs.len() == 1 {
-            word(s.s, ~",");
+            word(s.s, ",");
         }
         pclose(s);
       }
@@ -1161,12 +1161,12 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
         let mut base_args = copy *args;
         let blk = print_call_pre(s, sugar, &mut base_args);
         print_expr(s, func);
-        word(s.s, ~".");
+        word(s.s, ".");
         print_ident(s, ident);
         if tys.len() > 0u {
-            word(s.s, ~"::<");
+            word(s.s, "::<");
             commasep(s, inconsistent, *tys, print_type);
-            word(s.s, ~">");
+            word(s.s, ">");
         }
         print_call_post(s, sugar, &blk, &mut base_args);
       }
@@ -1181,7 +1181,7 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
         print_expr(s, expr);
       }
       ast::expr_addr_of(m, expr) => {
-        word(s.s, ~"&");
+        word(s.s, "&");
         print_mutability(s, m);
         // Avoid `& &e` => `&&e`.
         match (m, &expr.node) {
@@ -1194,32 +1194,32 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
       ast::expr_cast(expr, ty) => {
         print_expr(s, expr);
         space(s.s);
-        word_space(s, ~"as");
+        word_space(s, "as");
         print_type(s, ty);
       }
       ast::expr_if(test, ref blk, elseopt) => {
         print_if(s, test, blk, elseopt, false);
       }
       ast::expr_while(test, ref blk) => {
-        head(s, ~"while");
+        head(s, "while");
         print_expr(s, test);
         space(s.s);
         print_block(s, blk);
       }
       ast::expr_loop(ref blk, opt_ident) => {
         for opt_ident.each |ident| {
-            word(s.s, ~"'");
+            word(s.s, "'");
             print_ident(s, *ident);
-            word_space(s, ~":");
+            word_space(s, ":");
         }
-        head(s, ~"loop");
+        head(s, "loop");
         space(s.s);
         print_block(s, blk);
       }
       ast::expr_match(expr, ref arms) => {
         cbox(s, indent_unit);
         ibox(s, 4);
-        word_nbsp(s, ~"match");
+        word_nbsp(s, "match");
         print_expr(s, expr);
         space(s.s);
         bopen(s);
@@ -1232,19 +1232,19 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
             for arm.pats.each |p| {
                 if first {
                     first = false;
-                } else { space(s.s); word_space(s, ~"|"); }
+                } else { space(s.s); word_space(s, "|"); }
                 print_refutable_pat(s, *p);
             }
             space(s.s);
             match arm.guard {
               Some(e) => {
-                word_space(s, ~"if");
+                word_space(s, "if");
                 print_expr(s, e);
                 space(s.s);
               }
               None => ()
             }
-            word_space(s, ~"=>");
+            word_space(s, "=>");
 
             // Extract the expression from the extra block the parser adds
             // in the case of foo => expr
@@ -1268,7 +1268,7 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
                         }
                         if !expr_is_simple_block(expr)
                             && i < len - 1 {
-                            word(s.s, ~",");
+                            word(s.s, ",");
                         }
                         end(s); // close enclosing cbox
                     }
@@ -1321,97 +1321,97 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
         ibox(s, 0u);
         print_block(s, blk);
       }
-      ast::expr_copy(e) => { word_space(s, ~"copy"); print_expr(s, e); }
+      ast::expr_copy(e) => { word_space(s, "copy"); print_expr(s, e); }
       ast::expr_assign(lhs, rhs) => {
         print_expr(s, lhs);
         space(s.s);
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_expr(s, rhs);
       }
       ast::expr_assign_op(op, lhs, rhs) => {
         print_expr(s, lhs);
         space(s.s);
         word(s.s, ast_util::binop_to_str(op));
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_expr(s, rhs);
       }
       ast::expr_field(expr, id, ref tys) => {
         print_expr(s, expr);
-        word(s.s, ~".");
+        word(s.s, ".");
         print_ident(s, id);
         if tys.len() > 0u {
-            word(s.s, ~"::<");
+            word(s.s, "::<");
             commasep(s, inconsistent, *tys, print_type);
-            word(s.s, ~">");
+            word(s.s, ">");
         }
       }
       ast::expr_index(expr, index) => {
         print_expr(s, expr);
-        word(s.s, ~"[");
+        word(s.s, "[");
         print_expr(s, index);
-        word(s.s, ~"]");
+        word(s.s, "]");
       }
       ast::expr_path(path) => print_path(s, path, true),
-      ast::expr_self => word(s.s, ~"self"),
+      ast::expr_self => word(s.s, "self"),
       ast::expr_break(opt_ident) => {
-        word(s.s, ~"break");
+        word(s.s, "break");
         space(s.s);
         for opt_ident.each |ident| {
-            word(s.s, ~"'");
+            word(s.s, "'");
             print_ident(s, *ident);
             space(s.s);
         }
       }
       ast::expr_again(opt_ident) => {
-        word(s.s, ~"loop");
+        word(s.s, "loop");
         space(s.s);
         for opt_ident.each |ident| {
-            word(s.s, ~"'");
+            word(s.s, "'");
             print_ident(s, *ident);
             space(s.s)
         }
       }
       ast::expr_ret(result) => {
-        word(s.s, ~"return");
+        word(s.s, "return");
         match result {
-          Some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
+          Some(expr) => { word(s.s, " "); print_expr(s, expr); }
           _ => ()
         }
       }
       ast::expr_log(lexp, expr) => {
-        word(s.s, ~"__log");
+        word(s.s, "__log");
         popen(s);
         print_expr(s, lexp);
-        word(s.s, ~",");
+        word(s.s, ",");
         space_if_not_bol(s);
         print_expr(s, expr);
         pclose(s);
       }
       ast::expr_inline_asm(ref a) => {
         if a.volatile {
-            word(s.s, ~"__volatile__ asm!");
+            word(s.s, "__volatile__ asm!");
         } else {
-            word(s.s, ~"asm!");
+            word(s.s, "asm!");
         }
         popen(s);
         print_string(s, *a.asm);
-        word_space(s, ~":");
+        word_space(s, ":");
         for a.outputs.each |&(co, o)| {
             print_string(s, *co);
             popen(s);
             print_expr(s, o);
             pclose(s);
-            word_space(s, ~",");
+            word_space(s, ",");
         }
-        word_space(s, ~":");
+        word_space(s, ":");
         for a.inputs.each |&(co, o)| {
             print_string(s, *co);
             popen(s);
             print_expr(s, o);
             pclose(s);
-            word_space(s, ~",");
+            word_space(s, ",");
         }
-        word_space(s, ~":");
+        word_space(s, ":");
         print_string(s, *a.clobbers);
         pclose(s);
       }
@@ -1430,7 +1430,7 @@ pub fn print_local_decl(s: @ps, loc: @ast::local) {
     print_irrefutable_pat(s, loc.node.pat);
     match loc.node.ty.node {
       ast::ty_infer => (),
-      _ => { word_space(s, ~":"); print_type(s, loc.node.ty); }
+      _ => { word_space(s, ":"); print_type(s, loc.node.ty); }
     }
 }
 
@@ -1440,12 +1440,12 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
       ast::decl_local(ref locs) => {
         space_if_not_bol(s);
         ibox(s, indent_unit);
-        word_nbsp(s, ~"let");
+        word_nbsp(s, "let");
 
         // if any are mut, all are mut
         if locs.any(|l| l.node.is_mutbl) {
             assert!(locs.all(|l| l.node.is_mutbl));
-            word_nbsp(s, ~"mut");
+            word_nbsp(s, "mut");
         }
 
         fn print_local(s: @ps, loc: @ast::local) {
@@ -1455,7 +1455,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
             match loc.node.init {
               Some(init) => {
                 nbsp(s);
-                word_space(s, ~"=");
+                word_space(s, "=");
                 print_expr(s, init);
               }
               _ => ()
@@ -1475,34 +1475,34 @@ pub fn print_ident(s: @ps, ident: ast::ident) {
 pub fn print_for_decl(s: @ps, loc: @ast::local, coll: @ast::expr) {
     print_local_decl(s, loc);
     space(s.s);
-    word_space(s, ~"in");
+    word_space(s, "in");
     print_expr(s, coll);
 }
 
 pub fn print_path(s: @ps, path: @ast::Path, colons_before_params: bool) {
     maybe_print_comment(s, path.span.lo);
-    if path.global { word(s.s, ~"::"); }
+    if path.global { word(s.s, "::"); }
     let mut first = true;
     for path.idents.each |id| {
-        if first { first = false; } else { word(s.s, ~"::"); }
+        if first { first = false; } else { word(s.s, "::"); }
         print_ident(s, *id);
     }
     if path.rp.is_some() || !path.types.is_empty() {
-        if colons_before_params { word(s.s, ~"::"); }
+        if colons_before_params { word(s.s, "::"); }
 
         if path.rp.is_some() || !path.types.is_empty() {
-            word(s.s, ~"<");
+            word(s.s, "<");
 
             for path.rp.each |r| {
                 print_lifetime(s, *r);
                 if !path.types.is_empty() {
-                    word_space(s, ~",");
+                    word_space(s, ",");
                 }
             }
 
             commasep(s, inconsistent, path.types, print_type);
 
-            word(s.s, ~">");
+            word(s.s, ">");
         }
     }
 }
@@ -1522,16 +1522,16 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
     /* Pat isn't normalized, but the beauty of it
      is that it doesn't matter */
     match pat.node {
-      ast::pat_wild => word(s.s, ~"_"),
+      ast::pat_wild => word(s.s, "_"),
       ast::pat_ident(binding_mode, path, sub) => {
           if refutable {
               match binding_mode {
                   ast::bind_by_ref(mutbl) => {
-                      word_nbsp(s, ~"ref");
+                      word_nbsp(s, "ref");
                       print_mutability(s, mutbl);
                   }
                   ast::bind_by_copy => {
-                      word_nbsp(s, ~"copy");
+                      word_nbsp(s, "copy");
                   }
                   ast::bind_infer => {}
               }
@@ -1539,7 +1539,7 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
           print_path(s, path, true);
           match sub {
               Some(p) => {
-                  word(s.s, ~"@");
+                  word(s.s, "@");
                   print_pat(s, p, refutable);
               }
               None => ()
@@ -1548,7 +1548,7 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
       ast::pat_enum(path, ref args_) => {
         print_path(s, path, true);
         match *args_ {
-          None => word(s.s, ~"(*)"),
+          None => word(s.s, "(*)"),
           Some(ref args) => {
             if !args.is_empty() {
               popen(s);
@@ -1561,11 +1561,11 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
       }
       ast::pat_struct(path, ref fields, etc) => {
         print_path(s, path, true);
-        word(s.s, ~"{");
+        word(s.s, "{");
         fn print_field(s: @ps, f: ast::field_pat, refutable: bool) {
             cbox(s, indent_unit);
             print_ident(s, f.ident);
-            word_space(s, ~":");
+            word_space(s, ":");
             print_pat(s, f.pat, refutable);
             end(s);
         }
@@ -1574,53 +1574,53 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
                       |s, f| print_field(s,f,refutable),
                       get_span);
         if etc {
-            if fields.len() != 0u { word_space(s, ~","); }
-            word(s.s, ~"_");
+            if fields.len() != 0u { word_space(s, ","); }
+            word(s.s, "_");
         }
-        word(s.s, ~"}");
+        word(s.s, "}");
       }
       ast::pat_tup(ref elts) => {
         popen(s);
         commasep(s, inconsistent, *elts, |s, p| print_pat(s, p, refutable));
         if elts.len() == 1 {
-            word(s.s, ~",");
+            word(s.s, ",");
         }
         pclose(s);
       }
       ast::pat_box(inner) => {
-          word(s.s, ~"@");
+          word(s.s, "@");
           print_pat(s, inner, refutable);
       }
       ast::pat_uniq(inner) => {
-          word(s.s, ~"~");
+          word(s.s, "~");
           print_pat(s, inner, refutable);
       }
       ast::pat_region(inner) => {
-          word(s.s, ~"&");
+          word(s.s, "&");
           print_pat(s, inner, refutable);
       }
       ast::pat_lit(e) => print_expr(s, e),
       ast::pat_range(begin, end) => {
         print_expr(s, begin);
         space(s.s);
-        word(s.s, ~"..");
+        word(s.s, "..");
         print_expr(s, end);
       }
       ast::pat_vec(ref before, slice, ref after) => {
-        word(s.s, ~"[");
+        word(s.s, "[");
         do commasep(s, inconsistent, *before) |s, p| {
             print_pat(s, p, refutable);
         }
         for slice.each |&p| {
-            if !before.is_empty() { word_space(s, ~","); }
-            word(s.s, ~"..");
+            if !before.is_empty() { word_space(s, ","); }
+            word(s.s, "..");
             print_pat(s, p, refutable);
-            if !after.is_empty() { word_space(s, ~","); }
+            if !after.is_empty() { word_space(s, ","); }
         }
         do commasep(s, inconsistent, *after) |s, p| {
             print_pat(s, p, refutable);
         }
-        word(s.s, ~"]");
+        word(s.s, "]");
       }
     }
     (s.ann.post)(ann_node);
@@ -1634,18 +1634,18 @@ pub fn explicit_self_to_str(explicit_self: ast::explicit_self_, intr: @ident_int
 pub fn print_explicit_self(s: @ps, explicit_self: ast::explicit_self_) -> bool {
     match explicit_self {
         ast::sty_static => { return false; }
-        ast::sty_value => { word(s.s, ~"self"); }
+        ast::sty_value => { word(s.s, "self"); }
         ast::sty_region(lt, m) => {
-            word(s.s, ~"&");
+            word(s.s, "&");
             print_opt_lifetime(s, lt);
             print_mutability(s, m);
-            word(s.s, ~"self");
+            word(s.s, "self");
         }
         ast::sty_box(m) => {
-            word(s.s, ~"@"); print_mutability(s, m); word(s.s, ~"self");
+            word(s.s, "@"); print_mutability(s, m); word(s.s, "self");
         }
         ast::sty_uniq(m) => {
-            word(s.s, ~"~"); print_mutability(s, m); word(s.s, ~"self");
+            word(s.s, "~"); print_mutability(s, m); word(s.s, "self");
         }
     }
     return true;
@@ -1659,7 +1659,7 @@ pub fn print_fn(s: @ps,
                 generics: &ast::Generics,
                 opt_explicit_self: Option<ast::explicit_self_>,
                 vis: ast::visibility) {
-    head(s, ~"");
+    head(s, "");
     print_fn_header_info(s, opt_explicit_self, purity, abis, ast::Many, None, vis);
     nbsp(s);
     print_ident(s, name);
@@ -1678,7 +1678,7 @@ pub fn print_fn_args(s: @ps, decl: &ast::fn_decl,
     }
 
     for decl.inputs.each |arg| {
-        if first { first = false; } else { word_space(s, ~","); }
+        if first { first = false; } else { word_space(s, ","); }
         print_arg(s, *arg);
     }
 
@@ -1696,22 +1696,22 @@ pub fn print_fn_args_and_ret(s: @ps, decl: &ast::fn_decl,
         ast::ty_nil => {}
         _ => {
             space_if_not_bol(s);
-            word_space(s, ~"->");
+            word_space(s, "->");
             print_type(s, decl.output);
         }
     }
 }
 
 pub fn print_fn_block_args(s: @ps, decl: &ast::fn_decl) {
-    word(s.s, ~"|");
+    word(s.s, "|");
     print_fn_args(s, decl, None);
-    word(s.s, ~"|");
+    word(s.s, "|");
 
     match decl.output.node {
         ast::ty_infer => {}
         _ => {
             space_if_not_bol(s);
-            word_space(s, ~"->");
+            word_space(s, "->");
             print_type(s, decl.output);
         }
     }
@@ -1721,33 +1721,33 @@ pub fn print_fn_block_args(s: @ps, decl: &ast::fn_decl) {
 
 pub fn print_bounds(s: @ps, bounds: @OptVec<ast::TyParamBound>) {
     if !bounds.is_empty() {
-        word(s.s, ~":");
+        word(s.s, ":");
         let mut first = true;
         for bounds.each |bound| {
             nbsp(s);
             if first {
                 first = false;
             } else {
-                word_space(s, ~"+");
+                word_space(s, "+");
             }
 
             match *bound {
                 TraitTyParamBound(tref) => print_trait_ref(s, tref),
-                RegionTyParamBound => word(s.s, ~"'static"),
+                RegionTyParamBound => word(s.s, "'static"),
             }
         }
     }
 }
 
 pub fn print_lifetime(s: @ps, lifetime: &ast::Lifetime) {
-    word(s.s, ~"'");
+    word(s.s, "'");
     print_ident(s, lifetime.ident);
 }
 
 pub fn print_generics(s: @ps, generics: &ast::Generics) {
     let total = generics.lifetimes.len() + generics.ty_params.len();
     if total > 0 {
-        word(s.s, ~"<");
+        word(s.s, "<");
         fn print_item(s: @ps, generics: &ast::Generics, idx: uint) {
             if idx < generics.lifetimes.len() {
                 let lifetime = generics.lifetimes.get(idx);
@@ -1767,7 +1767,7 @@ pub fn print_generics(s: @ps, generics: &ast::Generics) {
 
         commasep(s, inconsistent, ints,
                  |s, i| print_item(s, generics, i));
-        word(s.s, ~">");
+        word(s.s, ">");
     }
 }
 
@@ -1777,7 +1777,7 @@ pub fn print_meta_item(s: @ps, item: @ast::meta_item) {
       ast::meta_word(name) => word(s.s, *name),
       ast::meta_name_value(name, value) => {
         word_space(s, *name);
-        word_space(s, ~"=");
+        word_space(s, "=");
         print_literal(s, @value);
       }
       ast::meta_list(name, ref items) => {
@@ -1801,23 +1801,23 @@ pub fn print_view_path(s: @ps, vp: @ast::view_path) {
         if path.idents[path.idents.len()-1u] != ident {
             print_ident(s, ident);
             space(s.s);
-            word_space(s, ~"=");
+            word_space(s, "=");
         }
         print_path(s, path, false);
       }
 
       ast::view_path_glob(path, _) => {
         print_path(s, path, false);
-        word(s.s, ~"::*");
+        word(s.s, "::*");
       }
 
       ast::view_path_list(path, ref idents, _) => {
         print_path(s, path, false);
-        word(s.s, ~"::{");
+        word(s.s, "::{");
         do commasep(s, inconsistent, (*idents)) |s, w| {
             print_ident(s, w.node.name);
         }
-        word(s.s, ~"}");
+        word(s.s, "}");
       }
     }
 }
@@ -1833,7 +1833,7 @@ pub fn print_view_item(s: @ps, item: @ast::view_item) {
     print_visibility(s, item.vis);
     match item.node {
         ast::view_item_extern_mod(id, ref mta, _) => {
-            head(s, ~"extern mod");
+            head(s, "extern mod");
             print_ident(s, id);
             if !mta.is_empty() {
                 popen(s);
@@ -1843,19 +1843,19 @@ pub fn print_view_item(s: @ps, item: @ast::view_item) {
         }
 
         ast::view_item_use(ref vps) => {
-            head(s, ~"use");
+            head(s, "use");
             print_view_paths(s, *vps);
         }
     }
-    word(s.s, ~";");
+    word(s.s, ";");
     end(s); // end inner head-block
     end(s); // end outer head-block
 }
 
 pub fn print_mutability(s: @ps, mutbl: ast::mutability) {
     match mutbl {
-      ast::m_mutbl => word_nbsp(s, ~"mut"),
-      ast::m_const => word_nbsp(s, ~"const"),
+      ast::m_mutbl => word_nbsp(s, "mut"),
+      ast::m_const => word_nbsp(s, "const"),
       ast::m_imm => {/* nothing */ }
     }
 }
@@ -1868,7 +1868,7 @@ pub fn print_mt(s: @ps, mt: &ast::mt) {
 pub fn print_arg(s: @ps, input: ast::arg) {
     ibox(s, indent_unit);
     if input.is_mutbl {
-        word_space(s, ~"mut");
+        word_space(s, "mut");
     }
     match input.ty.node {
       ast::ty_infer => print_irrefutable_pat(s, input.pat),
@@ -1881,7 +1881,7 @@ pub fn print_arg(s: @ps, input: ast::arg) {
             }
             _ => {
                 print_irrefutable_pat(s, input.pat);
-                word(s.s, ~":");
+                word(s.s, ":");
                 space(s.s);
             }
         }
@@ -1910,8 +1910,8 @@ pub fn print_ty_fn(s: @ps,
     print_opt_lifetime(s, opt_region);
     print_purity(s, purity);
     print_onceness(s, onceness);
-    word(s.s, ~"fn");
-    match id { Some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () }
+    word(s.s, "fn");
+    match id { Some(id) => { word(s.s, " "); print_ident(s, id); } _ => () }
     match generics { Some(g) => print_generics(s, g), _ => () }
     zerobreak(s.s);
 
@@ -1924,7 +1924,7 @@ pub fn print_ty_fn(s: @ps,
         first = !print_explicit_self(s, *explicit_self);
     }
     for decl.inputs.each |arg| {
-        if first { first = false; } else { word_space(s, ~","); }
+        if first { first = false; } else { word_space(s, ","); }
         print_arg(s, *arg);
     }
     end(s);
@@ -1937,8 +1937,8 @@ pub fn print_ty_fn(s: @ps,
         _ => {
             space_if_not_bol(s);
             ibox(s, indent_unit);
-            word_space(s, ~"->");
-            if decl.cf == ast::noreturn { word_nbsp(s, ~"!"); }
+            word_space(s, "->");
+            if decl.cf == ast::noreturn { word_nbsp(s, "!"); }
             else { print_type(s, decl.output); }
             end(s);
         }
@@ -2024,9 +2024,9 @@ pub fn print_literal(s: @ps, lit: @ast::lit) {
         word(s.s, *f + ast_util::float_ty_to_str(t));
       }
       ast::lit_float_unsuffixed(f) => word(s.s, *f),
-      ast::lit_nil => word(s.s, ~"()"),
+      ast::lit_nil => word(s.s, "()"),
       ast::lit_bool(val) => {
-        if val { word(s.s, ~"true"); } else { word(s.s, ~"false"); }
+        if val { word(s.s, "true"); } else { word(s.s, "false"); }
       }
     }
 }
@@ -2082,7 +2082,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
         }
       }
       comments::trailing => {
-        word(s.s, ~" ");
+        word(s.s, " ");
         if cmnt.lines.len() == 1u {
             word(s.s, cmnt.lines[0]);
             hardbreak(s.s);
@@ -2109,9 +2109,9 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
 }
 
 pub fn print_string(s: @ps, st: &str) {
-    word(s.s, ~"\"");
+    word(s.s, "\"");
     word(s.s, str::escape_default(st));
-    word(s.s, ~"\"");
+    word(s.s, "\"");
 }
 
 pub fn to_str<T: Copy>(t: T, f: @fn(@ps, T), intr: @ident_interner) -> ~str {
@@ -2146,7 +2146,7 @@ pub fn print_opt_purity(s: @ps, opt_purity: Option<ast::purity>) {
 pub fn print_extern_opt_abis(s: @ps, opt_abis: Option<AbiSet>) {
     match opt_abis {
         Some(abis) => {
-            word_nbsp(s, ~"extern");
+            word_nbsp(s, "extern");
             word_nbsp(s, abis.to_str());
         }
         None => {}
@@ -2155,9 +2155,9 @@ pub fn print_extern_opt_abis(s: @ps, opt_abis: Option<AbiSet>) {
 
 pub fn print_opt_sigil(s: @ps, opt_sigil: Option<ast::Sigil>) {
     match opt_sigil {
-        Some(ast::BorrowedSigil) => { word(s.s, ~"&"); }
-        Some(ast::OwnedSigil) => { word(s.s, ~"~"); }
-        Some(ast::ManagedSigil) => { word(s.s, ~"@"); }
+        Some(ast::BorrowedSigil) => { word(s.s, "&"); }
+        Some(ast::OwnedSigil) => { word(s.s, "~"); }
+        Some(ast::ManagedSigil) => { word(s.s, "@"); }
         None => {}
     };
 }
@@ -2172,7 +2172,7 @@ pub fn print_fn_header_info(s: @ps,
     word(s.s, visibility_qualified(vis, ~""));
 
     if abis != AbiSet::Rust() {
-        word_nbsp(s, ~"extern");
+        word_nbsp(s, "extern");
         word_nbsp(s, abis.to_str());
 
         if opt_purity != Some(ast::extern_fn) {
@@ -2183,7 +2183,7 @@ pub fn print_fn_header_info(s: @ps,
     }
 
     print_onceness(s, onceness);
-    word(s.s, ~"fn");
+    word(s.s, "fn");
     print_opt_sigil(s, opt_sigil);
 }
 
@@ -2219,7 +2219,7 @@ pub fn print_purity(s: @ps, p: ast::purity) {
 
 pub fn print_onceness(s: @ps, o: ast::Onceness) {
     match o {
-        ast::Once => { word_nbsp(s, ~"once"); }
+        ast::Once => { word_nbsp(s, "once"); }
         ast::Many => {}
     }
 }