Use @str instead of @~str in libsyntax and librustc. Fixes #5048.

This almost removes the StringRef wrapper, since all strings are
Equiv-alent now. Removes a lot of `/* bad */ copy *`'s, and converts
several things to be &'static str (the lint table and the intrinsics
table).

There are many instances of .to_managed(), unfortunately.

19 files changed, 219 insertions, 221 deletions

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index f9f9f7216a4..0394ccb3efb 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -45,7 +45,7 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
                                        cx.cfg(),
                                        tts.to_owned());
 
-    let mut asm = ~"";
+    let mut asm = @"";
     let mut outputs = ~[];
     let mut inputs = ~[];
     let mut cons = ~"";
@@ -113,7 +113,7 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
                         p.eat(&token::COMMA);
                     }
 
-                    let clob = ~"~{" + *p.parse_str() + "}";
+                    let clob = fmt!("~{%s}", p.parse_str());
                     clobs.push(clob);
                 }
 
@@ -122,11 +122,11 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
             Options => {
                 let option = p.parse_str();
 
-                if "volatile" == *option {
+                if "volatile" == option {
                     volatile = true;
-                } else if "alignstack" == *option {
+                } else if "alignstack" == option {
                     alignstack = true;
-                } else if "intel" == *option {
+                } else if "intel" == option {
                     dialect = ast::asm_intel;
                 }
 
@@ -176,8 +176,8 @@ pub fn expand_asm(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     MRExpr(@ast::expr {
         id: cx.next_id(),
         node: ast::expr_inline_asm(ast::inline_asm {
-            asm: @asm,
-            clobbers: @cons,
+            asm: asm,
+            clobbers: cons.to_managed(),
             inputs: inputs,
             outputs: outputs,
             volatile: volatile,
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 73f68735bcd..8e30a5880d5 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -33,7 +33,7 @@ use core::hashmap::HashMap;
 // ast::mac_invoc_tt.
 
 pub struct MacroDef {
-    name: ~str,
+    name: @str,
     ext: SyntaxExtension
 }
 
@@ -308,18 +308,18 @@ impl ExtCtxt {
     pub fn set_trace_macros(&self, x: bool) {
         *self.trace_mac = x
     }
-    pub fn str_of(&self, id: ast::ident) -> ~str {
-        copy *ident_to_str(&id)
+    pub fn str_of(&self, id: ast::ident) -> @str {
+        ident_to_str(&id)
     }
     pub fn ident_of(&self, st: &str) -> ast::ident {
         str_to_ident(st)
     }
 }
 
-pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::expr, err_msg: ~str) -> ~str {
+pub fn expr_to_str(cx: @ExtCtxt, expr: @ast::expr, err_msg: ~str) -> @str {
     match expr.node {
       ast::expr_lit(l) => match l.node {
-        ast::lit_str(s) => copy *s,
+        ast::lit_str(s) => s,
         _ => cx.span_fatal(l.span, err_msg)
       },
       _ => cx.span_fatal(expr.span, err_msg)
@@ -350,7 +350,7 @@ pub fn check_zero_tts(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree],
 pub fn get_single_str_from_tts(cx: @ExtCtxt,
                                sp: span,
                                tts: &[ast::token_tree],
-                               name: &str) -> ~str {
+                               name: &str) -> @str {
     if tts.len() != 1 {
         cx.span_fatal(sp, fmt!("%s takes 1 argument.", name));
     }
@@ -538,25 +538,25 @@ mod test {
 
     #[test] fn testenv () {
         let mut a = HashMap::new();
-        a.insert (@~"abc",@15);
+        a.insert (@"abc",@15);
         let m = MapChain::new(~a);
-        m.insert (@~"def",@16);
-        // FIXME: #4492 (ICE)  assert_eq!(m.find(&@~"abc"),Some(@15));
-        //  ....               assert_eq!(m.find(&@~"def"),Some(@16));
-        assert_eq!(*(m.find(&@~"abc").get()),15);
-        assert_eq!(*(m.find(&@~"def").get()),16);
+        m.insert (@"def",@16);
+        // FIXME: #4492 (ICE)  assert_eq!(m.find(&@"abc"),Some(@15));
+        //  ....               assert_eq!(m.find(&@"def"),Some(@16));
+        assert_eq!(*(m.find(&@"abc").get()),15);
+        assert_eq!(*(m.find(&@"def").get()),16);
         let n = m.push_frame();
         // old bindings are still present:
-        assert_eq!(*(n.find(&@~"abc").get()),15);
-        assert_eq!(*(n.find(&@~"def").get()),16);
-        n.insert (@~"def",@17);
+        assert_eq!(*(n.find(&@"abc").get()),15);
+        assert_eq!(*(n.find(&@"def").get()),16);
+        n.insert (@"def",@17);
         // n shows the new binding
-        assert_eq!(*(n.find(&@~"abc").get()),15);
-        assert_eq!(*(n.find(&@~"def").get()),17);
+        assert_eq!(*(n.find(&@"abc").get()),15);
+        assert_eq!(*(n.find(&@"def").get()),17);
         // ... but m still has the old ones
-        // FIXME: #4492: assert_eq!(m.find(&@~"abc"),Some(@15));
-        // FIXME: #4492: assert_eq!(m.find(&@~"def"),Some(@16));
-        assert_eq!(*(m.find(&@~"abc").get()),15);
-        assert_eq!(*(m.find(&@~"def").get()),16);
+        // FIXME: #4492: assert_eq!(m.find(&@"abc"),Some(@15));
+        // FIXME: #4492: assert_eq!(m.find(&@"def"),Some(@16));
+        assert_eq!(*(m.find(&@"abc").get()),15);
+        assert_eq!(*(m.find(&@"def").get()),16);
     }
 }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 324b909fbb0..dc31a248065 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -126,8 +126,8 @@ pub trait AstBuilder {
     fn expr_vec(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
     fn expr_vec_uniq(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
     fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr;
-    fn expr_str(&self, sp: span, s: ~str) -> @ast::expr;
-    fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr;
+    fn expr_str(&self, sp: span, s: @str) -> @ast::expr;
+    fn expr_str_uniq(&self, sp: span, s: @str) -> @ast::expr;
 
     fn expr_unreachable(&self, span: span) -> @ast::expr;
 
@@ -215,9 +215,9 @@ pub trait AstBuilder {
 
     fn attribute(&self, sp: span, mi: @ast::meta_item) -> ast::attribute;
 
-    fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item;
-    fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item;
-    fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item;
+    fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item;
+    fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item;
+    fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item;
 
     fn view_use(&self, sp: span,
                 vis: ast::visibility, vp: ~[@ast::view_path]) -> @ast::view_item;
@@ -521,10 +521,10 @@ impl AstBuilder for @ExtCtxt {
     fn expr_vec_slice(&self, sp: span, exprs: ~[@ast::expr]) -> @ast::expr {
         self.expr_vstore(sp, self.expr_vec(sp, exprs), ast::expr_vstore_slice)
     }
-    fn expr_str(&self, sp: span, s: ~str) -> @ast::expr {
-        self.expr_lit(sp, ast::lit_str(@s))
+    fn expr_str(&self, sp: span, s: @str) -> @ast::expr {
+        self.expr_lit(sp, ast::lit_str(s))
     }
-    fn expr_str_uniq(&self, sp: span, s: ~str) -> @ast::expr {
+    fn expr_str_uniq(&self, sp: span, s: @str) -> @ast::expr {
         self.expr_vstore(sp, self.expr_str(sp, s), ast::expr_vstore_uniq)
     }
 
@@ -540,8 +540,8 @@ impl AstBuilder for @ExtCtxt {
                 self.ident_of("fail_with"),
             ],
             ~[
-                self.expr_str(span, ~"internal error: entered unreachable code"),
-                self.expr_str(span, copy loc.file.name),
+                self.expr_str(span, @"internal error: entered unreachable code"),
+                self.expr_str(span, loc.file.name),
                 self.expr_uint(span, loc.line),
             ])
     }
@@ -791,14 +791,14 @@ impl AstBuilder for @ExtCtxt {
                })
     }
 
-    fn meta_word(&self, sp: span, w: ~str) -> @ast::meta_item {
-        @respan(sp, ast::meta_word(@w))
+    fn meta_word(&self, sp: span, w: @str) -> @ast::meta_item {
+        @respan(sp, ast::meta_word(w))
     }
-    fn meta_list(&self, sp: span, name: ~str, mis: ~[@ast::meta_item]) -> @ast::meta_item {
-        @respan(sp, ast::meta_list(@name, mis))
+    fn meta_list(&self, sp: span, name: @str, mis: ~[@ast::meta_item]) -> @ast::meta_item {
+        @respan(sp, ast::meta_list(name, mis))
     }
-    fn meta_name_value(&self, sp: span, name: ~str, value: ast::lit_) -> @ast::meta_item {
-        @respan(sp, ast::meta_name_value(@name, respan(sp, value)))
+    fn meta_name_value(&self, sp: span, name: @str, value: ast::lit_) -> @ast::meta_item {
+        @respan(sp, ast::meta_name_value(name, respan(sp, value)))
     }
 
     fn view_use(&self, sp: span,
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index 2081f262825..abea7912fc8 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -72,7 +72,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
             };
             let read_struct_field = cx.ident_of("read_struct_field");
 
-            let getarg = |name: ~str, field: uint| {
+            let getarg = |name: @str, field: uint| {
                 cx.expr_method_call(span, blkdecoder, read_struct_field,
                                     ~[cx.expr_str(span, name),
                                       cx.expr_uint(span, field),
@@ -86,7 +86,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
                     } else {
                         let mut fields = vec::with_capacity(n);
                         for uint::range(0, n) |i| {
-                            fields.push(getarg(fmt!("_field%u", i), i));
+                            fields.push(getarg(fmt!("_field%u", i).to_managed(), i));
                         }
                         cx.expr_call_ident(span, substr.type_ident, fields)
                     }
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 2d24de553d6..d7e64caa5c8 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -127,7 +127,7 @@ fn encodable_substructure(cx: @ExtCtxt, span: span,
             for fields.eachi |i, f| {
                 let (name, val) = match *f {
                     (Some(id), e, _) => (cx.str_of(id), e),
-                    (None, e, _) => (fmt!("_field%u", i), e)
+                    (None, e, _) => (fmt!("_field%u", i).to_managed(), e)
                 };
                 let enc = cx.expr_method_call(span, val, encode, ~[blkencoder]);
                 let lambda = cx.lambda_expr_1(span, enc, blkarg);
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 078fd4231ca..5d07171bbb1 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -364,7 +364,7 @@ impl<'self> TraitDef<'self> {
         let doc_attr = cx.attribute(
             span,
             cx.meta_name_value(span,
-                               ~"doc", ast::lit_str(@~"Automatically derived.")));
+                               @"doc", ast::lit_str(@"Automatically derived.")));
         cx.item(
             span,
             ::parse::token::special_idents::clownshoes_extensions,
diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs
index c091ab8b617..606e372a25d 100644
--- a/src/libsyntax/ext/deriving/mod.rs
+++ b/src/libsyntax/ext/deriving/mod.rs
@@ -82,23 +82,23 @@ pub fn expand_meta_deriving(cx: @ExtCtxt,
                     meta_word(tname) => {
                         macro_rules! expand(($func:path) => ($func(cx, titem.span,
                                                                    titem, in_items)));
-                        match *tname {
-                            ~"Clone" => expand!(clone::expand_deriving_clone),
-                            ~"DeepClone" => expand!(clone::expand_deriving_deep_clone),
+                        match tname.as_slice() {
+                            "Clone" => expand!(clone::expand_deriving_clone),
+                            "DeepClone" => expand!(clone::expand_deriving_deep_clone),
 
-                            ~"IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes),
+                            "IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes),
 
-                            ~"Encodable" => expand!(encodable::expand_deriving_encodable),
-                            ~"Decodable" => expand!(decodable::expand_deriving_decodable),
+                            "Encodable" => expand!(encodable::expand_deriving_encodable),
+                            "Decodable" => expand!(decodable::expand_deriving_decodable),
 
-                            ~"Eq" => expand!(eq::expand_deriving_eq),
-                            ~"TotalEq" => expand!(totaleq::expand_deriving_totaleq),
-                            ~"Ord" => expand!(ord::expand_deriving_ord),
-                            ~"TotalOrd" => expand!(totalord::expand_deriving_totalord),
+                            "Eq" => expand!(eq::expand_deriving_eq),
+                            "TotalEq" => expand!(totaleq::expand_deriving_totaleq),
+                            "Ord" => expand!(ord::expand_deriving_ord),
+                            "TotalOrd" => expand!(totalord::expand_deriving_totalord),
 
-                            ~"Rand" => expand!(rand::expand_deriving_rand),
+                            "Rand" => expand!(rand::expand_deriving_rand),
 
-                            ~"ToStr" => expand!(to_str::expand_deriving_to_str),
+                            "ToStr" => expand!(to_str::expand_deriving_to_str),
 
                             ref tname => {
                                 cx.span_err(titem.span, fmt!("unknown \
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index 4d074b4d0e6..34be6fc8143 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -33,8 +33,8 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     // Option<str> rather than just an maybe-empty string.
 
     let e = match os::getenv(var) {
-      None => cx.expr_str(sp, ~""),
-      Some(ref s) => cx.expr_str(sp, copy *s)
+      None => cx.expr_str(sp, @""),
+      Some(s) => cx.expr_str(sp, s.to_managed())
     };
     MRExpr(e)
 }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index fe751d279d2..7ca8ab911de 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -57,7 +57,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
                         None => {
                             cx.span_fatal(
                                 pth.span,
-                                fmt!("macro undefined: '%s'", *extnamestr))
+                                fmt!("macro undefined: '%s'", extnamestr))
                         }
                         Some(@SE(NormalTT(SyntaxExpanderTT{
                             expander: exp,
@@ -66,7 +66,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
                             cx.bt_push(ExpandedFrom(CallInfo {
                                 call_site: s,
                                 callee: NameAndSpan {
-                                    name: copy *extnamestr,
+                                    name: extnamestr,
                                     span: exp_sp,
                                 },
                             }));
@@ -79,7 +79,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
                                         pth.span,
                                         fmt!(
                                             "non-expr macro in expr pos: %s",
-                                            *extnamestr
+                                            extnamestr
                                         )
                                     )
                                 }
@@ -95,7 +95,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
                         _ => {
                             cx.span_fatal(
                                 pth.span,
-                                fmt!("'%s' is not a tt-style macro", *extnamestr)
+                                fmt!("'%s' is not a tt-style macro", extnamestr)
                             )
                         }
                     }
@@ -132,12 +132,12 @@ pub fn expand_mod_items(extsbox: @mut SyntaxEnv,
         do item.attrs.rev_iter().fold(~[*item]) |items, attr| {
             let mname = attr::get_attr_name(attr);
 
-            match (*extsbox).find(&intern(*mname)) {
+            match (*extsbox).find(&intern(mname)) {
               Some(@SE(ItemDecorator(dec_fn))) => {
                   cx.bt_push(ExpandedFrom(CallInfo {
                       call_site: attr.span,
                       callee: NameAndSpan {
-                          name: /*bad*/ copy *mname,
+                          name: mname,
                           span: None
                       }
                   }));
@@ -201,7 +201,7 @@ pub fn expand_item(extsbox: @mut SyntaxEnv,
 
 // does this attribute list contain "macro_escape" ?
 pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool {
-    attrs.any(|attr| "macro_escape" == *attr::get_attr_name(attr))
+    attrs.any(|attr| "macro_escape" == attr::get_attr_name(attr))
 }
 
 // Support for item-position macro invocations, exactly the same
@@ -221,19 +221,19 @@ pub fn expand_item_mac(extsbox: @mut SyntaxEnv,
     let extnamestr = ident_to_str(extname);
     let expanded = match (*extsbox).find(&extname.name) {
         None => cx.span_fatal(pth.span,
-                              fmt!("macro undefined: '%s!'", *extnamestr)),
+                              fmt!("macro undefined: '%s!'", extnamestr)),
 
         Some(@SE(NormalTT(ref expand))) => {
             if it.ident != parse::token::special_idents::invalid {
                 cx.span_fatal(pth.span,
                               fmt!("macro %s! expects no ident argument, \
-                                    given '%s'", *extnamestr,
-                                   *ident_to_str(&it.ident)));
+                                    given '%s'", extnamestr,
+                                   ident_to_str(&it.ident)));
             }
             cx.bt_push(ExpandedFrom(CallInfo {
                 call_site: it.span,
                 callee: NameAndSpan {
-                    name: copy *extnamestr,
+                    name: extnamestr,
                     span: expand.span
                 }
             }));
@@ -243,26 +243,25 @@ pub fn expand_item_mac(extsbox: @mut SyntaxEnv,
             if it.ident == parse::token::special_idents::invalid {
                 cx.span_fatal(pth.span,
                               fmt!("macro %s! expects an ident argument",
-                                   *extnamestr));
+                                   extnamestr));
             }
             cx.bt_push(ExpandedFrom(CallInfo {
                 call_site: it.span,
                 callee: NameAndSpan {
-                    name: copy *extnamestr,
+                    name: extnamestr,
                     span: expand.span
                 }
             }));
             ((*expand).expander)(cx, it.span, it.ident, tts)
         }
         _ => cx.span_fatal(
-            it.span, fmt!("%s! is not legal in item position", *extnamestr))
+            it.span, fmt!("%s! is not legal in item position", extnamestr))
     };
 
     let maybe_it = match expanded {
         MRItem(it) => fld.fold_item(it),
         MRExpr(_) => cx.span_fatal(pth.span,
-                                    ~"expr macro in item position: "
-                                    + *extnamestr),
+                                   fmt!("expr macro in item position: %s", extnamestr)),
         MRAny(_, item_maker, _) => item_maker().chain(|i| {fld.fold_item(i)}),
         MRDef(ref mdef) => {
             insert_macro(*extsbox,intern(mdef.name), @SE((*mdef).ext));
@@ -319,13 +318,13 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv,
     let extnamestr = ident_to_str(extname);
     let (fully_expanded, sp) = match (*extsbox).find(&extname.name) {
         None =>
-            cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extnamestr)),
+            cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", extnamestr)),
 
         Some(@SE(NormalTT(
             SyntaxExpanderTT{expander: exp, span: exp_sp}))) => {
             cx.bt_push(ExpandedFrom(CallInfo {
                 call_site: sp,
-                callee: NameAndSpan { name: copy *extnamestr, span: exp_sp }
+                callee: NameAndSpan { name: extnamestr, span: exp_sp }
             }));
             let expanded = match exp(cx, mac.span, tts) {
                 MRExpr(e) =>
@@ -334,7 +333,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv,
                 MRAny(_,_,stmt_mkr) => stmt_mkr(),
                 _ => cx.span_fatal(
                     pth.span,
-                    fmt!("non-stmt macro in stmt pos: %s", *extnamestr))
+                    fmt!("non-stmt macro in stmt pos: %s", extnamestr))
             };
 
             //keep going, outside-in
@@ -355,7 +354,7 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv,
 
         _ => {
             cx.span_fatal(pth.span,
-                          fmt!("'%s' is not a tt-style macro", *extnamestr))
+                          fmt!("'%s' is not a tt-style macro", extnamestr))
         }
     };
 
@@ -414,7 +413,7 @@ fn get_block_info(exts : SyntaxEnv) -> BlockInfo {
     match exts.find_in_topmost_frame(&intern(special_block_name)) {
         Some(@BlockInfo(bi)) => bi,
         _ => fail!(fmt!("special identifier %? was bound to a non-BlockInfo",
-                       @~" block"))
+                       @" block"))
     }
 }
 
@@ -456,9 +455,9 @@ pub fn new_span(cx: @ExtCtxt, sp: span) -> span {
 // the default compilation environment. It would be much nicer to use
 // a mechanism like syntax_quote to ensure hygiene.
 
-pub fn core_macros() -> ~str {
+pub fn core_macros() -> @str {
     return
-~"pub mod macros {
+@"pub mod macros {
     macro_rules! ignore (($($x:tt)*) => (()))
 
     macro_rules! error (
@@ -679,7 +678,7 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess,
             node: attribute_ {
                 style: attr_outer,
                 value: @spanned {
-                    node: meta_word(@~"macro_escape"),
+                    node: meta_word(@"macro_escape"),
                     span: codemap::dummy_sp(),
                 },
                 is_sugared_doc: false,
@@ -687,8 +686,8 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess,
         }
     ];
 
-    let cm = match parse_item_from_source_str(~"<core-macros>",
-                                              @core_macros(),
+    let cm = match parse_item_from_source_str(@"<core-macros>",
+                                              core_macros(),
                                               copy cfg,
                                               attrs,
                                               parse_sess) {
@@ -764,11 +763,11 @@ mod test {
 
     // make sure that fail! is present
     #[test] fn fail_exists_test () {
-        let src = ~"fn main() { fail!(\"something appropriately gloomy\");}";
+        let src = @"fn main() { fail!(\"something appropriately gloomy\");}";
         let sess = parse::new_parse_sess(None);
         let crate_ast = parse::parse_crate_from_source_str(
-            ~"<test>",
-            @src,
+            @"<test>",
+            src,
             ~[],sess);
         expand_crate(sess,~[],crate_ast);
     }
@@ -779,12 +778,12 @@ mod test {
     // make sure that macros can leave scope
     #[should_fail]
     #[test] fn macros_cant_escape_fns_test () {
-        let src = ~"fn bogus() {macro_rules! z (() => (3+4))}\
+        let src = @"fn bogus() {macro_rules! z (() => (3+4))}\
                     fn inty() -> int { z!() }";
         let sess = parse::new_parse_sess(None);
         let crate_ast = parse::parse_crate_from_source_str(
-            ~"<test>",
-            @src,
+            @"<test>",
+            src,
             ~[],sess);
         // should fail:
         expand_crate(sess,~[],crate_ast);
@@ -793,12 +792,12 @@ mod test {
     // make sure that macros can leave scope for modules
     #[should_fail]
     #[test] fn macros_cant_escape_mods_test () {
-        let src = ~"mod foo {macro_rules! z (() => (3+4))}\
+        let src = @"mod foo {macro_rules! z (() => (3+4))}\
                     fn inty() -> int { z!() }";
         let sess = parse::new_parse_sess(None);
         let crate_ast = parse::parse_crate_from_source_str(
-            ~"<test>",
-            @src,
+            @"<test>",
+            src,
             ~[],sess);
         // should fail:
         expand_crate(sess,~[],crate_ast);
@@ -806,19 +805,19 @@ mod test {
 
     // macro_escape modules shouldn't cause macros to leave scope
     #[test] fn macros_can_escape_flattened_mods_test () {
-        let src = ~"#[macro_escape] mod foo {macro_rules! z (() => (3+4))}\
+        let src = @"#[macro_escape] mod foo {macro_rules! z (() => (3+4))}\
                     fn inty() -> int { z!() }";
         let sess = parse::new_parse_sess(None);
         let crate_ast = parse::parse_crate_from_source_str(
-            ~"<test>",
-            @src,
+            @"<test>",
+            src,
             ~[], sess);
         // should fail:
         expand_crate(sess,~[],crate_ast);
     }
 
     #[test] fn core_macros_must_parse () {
-        let src = ~"
+        let src = @"
   pub mod macros {
     macro_rules! ignore (($($x:tt)*) => (()))
 
@@ -828,9 +827,9 @@ mod test {
         let sess = parse::new_parse_sess(None);
         let cfg = ~[];
         let item_ast = parse::parse_item_from_source_str(
-            ~"<test>",
-            @src,
-            cfg,~[make_dummy_attr (@~"macro_escape")],sess);
+            @"<test>",
+            src,
+            cfg,~[make_dummy_attr (@"macro_escape")],sess);
         match item_ast {
             Some(_) => (), // success
             None => fail!("expected this to parse")
@@ -838,9 +837,9 @@ mod test {
     }
 
     #[test] fn test_contains_flatten (){
-        let attr1 = make_dummy_attr (@~"foo");
-        let attr2 = make_dummy_attr (@~"bar");
-        let escape_attr = make_dummy_attr (@~"macro_escape");
+        let attr1 = make_dummy_attr (@"foo");
+        let attr2 = make_dummy_attr (@"bar");
+        let escape_attr = make_dummy_attr (@"macro_escape");
         let attrs1 = ~[attr1, escape_attr, attr2];
         assert_eq!(contains_macro_escape (attrs1),true);
         let attrs2 = ~[attr1,attr2];
@@ -848,7 +847,7 @@ mod test {
     }
 
     // make a "meta_word" outer attribute with the given name
-    fn make_dummy_attr(s: @~str) -> ast::attribute {
+    fn make_dummy_attr(s: @str) -> ast::attribute {
         spanned {
             span:codemap::dummy_sp(),
             node: attribute_ {
@@ -864,7 +863,7 @@ mod test {
 
     #[test]
     fn renaming () {
-        let maybe_item_ast = string_to_item(@~"fn a() -> int { let b = 13; b }");
+        let maybe_item_ast = string_to_item(@"fn a() -> int { let b = 13; b }");
         let item_ast = match maybe_item_ast {
             Some(x) => x,
             None => fail!("test case fail")
@@ -887,7 +886,7 @@ mod test {
 
     #[test]
     fn pat_idents(){
-        let pat = string_to_pat(@~"(a,Foo{x:c @ (b,9),y:Bar(4,d)})");
+        let pat = string_to_pat(@"(a,Foo{x:c @ (b,9),y:Bar(4,d)})");
         let pat_idents = new_name_finder();
         let idents = @mut ~[];
         ((*pat_idents).visit_pat)(pat, (idents, mk_vt(pat_idents)));
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index b2ec3684b70..74496ac5359 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -274,12 +274,13 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                    then there's no need for it to be mutable */
                 if i == 0 {
                     stms.push(cx.stmt_let(fmt_sp, npieces > 1,
-                                          ident, cx.expr_str_uniq(fmt_sp, s)));
+                                          ident, cx.expr_str_uniq(fmt_sp, s.to_managed())));
                 } else {
                     // we call the push_str function because the
                     // bootstrap doesnt't seem to work if we call the
                     // method.
-                    let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), cx.expr_str(fmt_sp, s)];
+                    let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()),
+                                 cx.expr_str(fmt_sp, s.to_managed())];
                     let call = cx.expr_call_global(fmt_sp,
                                                    ~[core_ident,
                                                      str_ident,
@@ -303,7 +304,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
                    must be initialized as an empty string */
                 if i == 0 {
                     stms.push(cx.stmt_let(fmt_sp, true, ident,
-                                          cx.expr_str_uniq(fmt_sp, ~"")));
+                                          cx.expr_str_uniq(fmt_sp, @"")));
                 }
                 stms.push(cx.stmt_expr(make_new_conv(cx, fmt_sp, conv,
                                                      args[n], buf())));
diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs
index 694a7c1cf84..c1b9b051ec9 100644
--- a/src/libsyntax/ext/pipes/check.rs
+++ b/src/libsyntax/ext/pipes/check.rs
@@ -51,7 +51,7 @@ impl proto::visitor<(), (), ()> for @ExtCtxt {
         }
     }
 
-    fn visit_message(&self, name: ~str, _span: span, _tys: &[@ast::Ty],
+    fn visit_message(&self, name: @str, _span: span, _tys: &[@ast::Ty],
                      this: state, next: Option<next_state>) {
         match next {
           Some(ref next_state) => {
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index a89fd26df4c..11db1a5da29 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -20,13 +20,13 @@ use parse::token;
 use parse::token::{interner_get};
 
 pub trait proto_parser {
-    fn parse_proto(&self, id: ~str) -> protocol;
+    fn parse_proto(&self, id: @str) -> protocol;
     fn parse_state(&self, proto: protocol);
     fn parse_message(&self, state: state);
 }
 
 impl proto_parser for parser::Parser {
-    fn parse_proto(&self, id: ~str) -> protocol {
+    fn parse_proto(&self, id: @str) -> protocol {
         let proto = protocol(id, *self.span);
 
         self.parse_seq_to_before_end(
@@ -43,7 +43,7 @@ impl proto_parser for parser::Parser {
 
     fn parse_state(&self, proto: protocol) {
         let id = self.parse_ident();
-        let name = copy *interner_get(id.name);
+        let name = interner_get(id.name);
 
         self.expect(&token::COLON);
         let dir = match copy *self.token {
@@ -51,9 +51,9 @@ impl proto_parser for parser::Parser {
             _ => fail!()
         };
         self.bump();
-        let dir = match dir {
-          @~"send" => send,
-          @~"recv" => recv,
+        let dir = match dir.as_slice() {
+          "send" => send,
+          "recv" => recv,
           _ => fail!()
         };
 
@@ -78,7 +78,7 @@ impl proto_parser for parser::Parser {
     }
 
     fn parse_message(&self, state: state) {
-        let mname = copy *interner_get(self.parse_ident().name);
+        let mname = interner_get(self.parse_ident().name);
 
         let args = if *self.token == token::LPAREN {
             self.parse_unspanned_seq(
@@ -97,7 +97,7 @@ impl proto_parser for parser::Parser {
 
         let next = match *self.token {
           token::IDENT(_, _) => {
-            let name = copy *interner_get(self.parse_ident().name);
+            let name = interner_get(self.parse_ident().name);
             let ntys = if *self.token == token::LT {
                 self.parse_unspanned_seq(
                     &token::LT,
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 304c496bbf4..b00f5057dac 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -101,7 +101,7 @@ impl gen_send for message {
                          name,
                          vec::append_one(
                              arg_names.map(|x| cx.str_of(*x)),
-                             ~"s").connect(", "));
+                             @"s").connect(", "));
 
             if !try {
                 body += fmt!("::std::pipes::send(pipe, message);\n");
@@ -114,7 +114,7 @@ impl gen_send for message {
                               } else { ::std::pipes::rt::make_none() } }");
             }
 
-            let body = cx.parse_expr(body);
+            let body = cx.parse_expr(body.to_managed());
 
             let mut rty = cx.ty_path(path(~[next.data_name()],
                                           span)
@@ -123,7 +123,7 @@ impl gen_send for message {
                 rty = cx.ty_option(rty);
             }
 
-            let name = cx.ident_of(if try { ~"try_" + name } else { name } );
+            let name = if try {cx.ident_of(~"try_" + name)} else {cx.ident_of(name)};
 
             cx.item_fn_poly(dummy_sp(),
                             name,
@@ -173,12 +173,12 @@ impl gen_send for message {
                                   } }");
                 }
 
-                let body = cx.parse_expr(body);
+                let body = cx.parse_expr(body.to_managed());
 
-                let name = if try { ~"try_" + name } else { name };
+                let name = if try {cx.ident_of(~"try_" + name)} else {cx.ident_of(name)};
 
                 cx.item_fn_poly(dummy_sp(),
-                                cx.ident_of(name),
+                                name,
                                 args_ast,
                                 if try {
                                     cx.ty_option(cx.ty_nil())
@@ -326,7 +326,7 @@ impl gen_init for protocol {
                            start_state.generics.to_source(),
                            start_state.to_ty(cx).to_source(),
                            start_state.to_ty(cx).to_source(),
-                           body.to_source()))
+                           body.to_source()).to_managed())
     }
 
     fn gen_buffer_init(&self, ext_cx: @ExtCtxt) -> @ast::expr {
@@ -358,10 +358,10 @@ impl gen_init for protocol {
                 self.states.map_to_vec(
                     |s| ext_cx.parse_stmt(
                         fmt!("data.%s.set_buffer(buffer)",
-                             s.name))),
+                             s.name).to_managed())),
                 Some(ext_cx.parse_expr(fmt!(
                     "::std::ptr::to_mut_unsafe_ptr(&mut (data.%s))",
-                    self.states[0].name)))));
+                    self.states[0].name).to_managed()))));
 
         quote_expr!({
             let buffer = $buffer;
@@ -459,9 +459,9 @@ impl gen_init for protocol {
         let allows = cx.attribute(
             copy self.span,
             cx.meta_list(copy self.span,
-                         ~"allow",
-                         ~[cx.meta_word(copy self.span, ~"non_camel_case_types"),
-                           cx.meta_word(copy self.span, ~"unused_mut")]));
+                         @"allow",
+                         ~[cx.meta_word(copy self.span, @"non_camel_case_types"),
+                           cx.meta_word(copy self.span, @"unused_mut")]));
         cx.item_mod(copy self.span, cx.ident_of(copy self.name),
                     ~[allows], ~[], items)
     }
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
index 0eb0f5c6159..32714f37272 100644
--- a/src/libsyntax/ext/pipes/proto.rs
+++ b/src/libsyntax/ext/pipes/proto.rs
@@ -38,17 +38,17 @@ impl direction {
 }
 
 pub struct next_state {
-    state: ~str,
+    state: @str,
     tys: ~[@ast::Ty],
 }
 
 // name, span, data, current state, next state
-pub struct message(~str, span, ~[@ast::Ty], state, Option<next_state>);
+pub struct message(@str, span, ~[@ast::Ty], state, Option<next_state>);
 
 impl message {
-    pub fn name(&mut self) -> ~str {
+    pub fn name(&mut self) -> @str {
         match *self {
-          message(ref id, _, _, _, _) => copy *id
+          message(id, _, _, _, _) => id
         }
     }
 
@@ -70,7 +70,7 @@ pub type state = @state_;
 
 pub struct state_ {
     id: uint,
-    name: ~str,
+    name: @str,
     ident: ast::ident,
     span: span,
     dir: direction,
@@ -81,7 +81,7 @@ pub struct state_ {
 
 impl state_ {
     pub fn add_message(@self,
-                       name: ~str,
+                       name: @str,
                        span: span,
                        data: ~[@ast::Ty],
                        next: Option<next_state>) {
@@ -122,11 +122,11 @@ impl state_ {
 
 pub type protocol = @mut protocol_;
 
-pub fn protocol(name: ~str, span: span) -> protocol {
+pub fn protocol(name: @str, span: span) -> protocol {
     @mut protocol_(name, span)
 }
 
-pub fn protocol_(name: ~str, span: span) -> protocol_ {
+pub fn protocol_(name: @str, span: span) -> protocol_ {
     protocol_ {
         name: name,
         span: span,
@@ -136,7 +136,7 @@ pub fn protocol_(name: ~str, span: span) -> protocol_ {
 }
 
 pub struct protocol_ {
-    name: ~str,
+    name: @str,
     span: span,
     states: @mut ~[state],
 
@@ -181,7 +181,7 @@ impl protocol_ {
 
 impl protocol_ {
     pub fn add_state_poly(@mut self,
-                          name: ~str,
+                          name: @str,
                           ident: ast::ident,
                           dir: direction,
                           generics: ast::Generics)
@@ -208,7 +208,7 @@ impl protocol_ {
 pub trait visitor<Tproto, Tstate, Tmessage> {
     fn visit_proto(&self, proto: protocol, st: &[Tstate]) -> Tproto;
     fn visit_state(&self, state: state, m: &[Tmessage]) -> Tstate;
-    fn visit_message(&self, name: ~str, spane: span, tys: &[@ast::Ty],
+    fn visit_message(&self, name: @str, spane: span, tys: &[@ast::Ty],
                      this: state, next: Option<next_state>) -> Tmessage;
 }
 
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 92727c73977..5e47862a1f0 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -43,8 +43,6 @@ pub mod rt {
     pub use parse::new_parser_from_tts;
     pub use codemap::{BytePos, span, dummy_spanned};
 
-    use print::pprust::{item_to_str, ty_to_str};
-
     pub trait ToTokens {
         pub fn to_tokens(&self, _cx: @ExtCtxt) -> ~[token_tree];
     }
@@ -71,132 +69,132 @@ pub mod rt {
 
     pub trait ToSource {
         // Takes a thing and generates a string containing rust code for it.
-        pub fn to_source(&self) -> ~str;
+        pub fn to_source(&self) -> @str;
     }
 
     impl ToSource for ast::ident {
-        fn to_source(&self) -> ~str {
-            copy *ident_to_str(self)
+        fn to_source(&self) -> @str {
+            ident_to_str(self)
         }
     }
 
     impl ToSource for @ast::item {
-        fn to_source(&self) -> ~str {
-            item_to_str(*self, get_ident_interner())
+        fn to_source(&self) -> @str {
+            pprust::item_to_str(*self, get_ident_interner()).to_managed()
         }
     }
 
     impl<'self> ToSource for &'self [@ast::item] {
-        fn to_source(&self) -> ~str {
-            self.map(|i| i.to_source()).connect("\n\n")
+        fn to_source(&self) -> @str {
+            self.map(|i| i.to_source()).connect("\n\n").to_managed()
         }
     }
 
     impl ToSource for @ast::Ty {
-        fn to_source(&self) -> ~str {
-            ty_to_str(*self, get_ident_interner())
+        fn to_source(&self) -> @str {
+            pprust::ty_to_str(*self, get_ident_interner()).to_managed()
         }
     }
 
     impl<'self> ToSource for &'self [@ast::Ty] {
-        fn to_source(&self) -> ~str {
-            self.map(|i| i.to_source()).connect(", ")
+        fn to_source(&self) -> @str {
+            self.map(|i| i.to_source()).connect(", ").to_managed()
         }
     }
 
     impl ToSource for Generics {
-        fn to_source(&self) -> ~str {
-            pprust::generics_to_str(self, get_ident_interner())
+        fn to_source(&self) -> @str {
+            pprust::generics_to_str(self, get_ident_interner()).to_managed()
         }
     }
 
     impl ToSource for @ast::expr {
-        fn to_source(&self) -> ~str {
-            pprust::expr_to_str(*self, get_ident_interner())
+        fn to_source(&self) -> @str {
+            pprust::expr_to_str(*self, get_ident_interner()).to_managed()
         }
     }
 
     impl ToSource for ast::blk {
-        fn to_source(&self) -> ~str {
-            pprust::block_to_str(self, get_ident_interner())
+        fn to_source(&self) -> @str {
+            pprust::block_to_str(self, get_ident_interner()).to_managed()
         }
     }
 
     impl<'self> ToSource for &'self str {
-        fn to_source(&self) -> ~str {
-            let lit = dummy_spanned(ast::lit_str(@self.to_owned()));
-            pprust::lit_to_str(@lit)
+        fn to_source(&self) -> @str {
+            let lit = dummy_spanned(ast::lit_str(self.to_managed()));
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for int {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for i8 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i8));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for i16 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i16));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
 
     impl ToSource for i32 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i32));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for i64 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i64));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for uint {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for u8 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u8));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for u16 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u16));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for u32 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u32));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
     impl ToSource for u64 {
-        fn to_source(&self) -> ~str {
+        fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u64));
-            pprust::lit_to_str(@lit)
+            pprust::lit_to_str(@lit).to_managed()
         }
     }
 
@@ -317,18 +315,18 @@ pub mod rt {
     }
 
     pub trait ExtParseUtils {
-        fn parse_item(&self, s: ~str) -> @ast::item;
-        fn parse_expr(&self, s: ~str) -> @ast::expr;
-        fn parse_stmt(&self, s: ~str) -> @ast::stmt;
-        fn parse_tts(&self, s: ~str) -> ~[ast::token_tree];
+        fn parse_item(&self, s: @str) -> @ast::item;
+        fn parse_expr(&self, s: @str) -> @ast::expr;
+        fn parse_stmt(&self, s: @str) -> @ast::stmt;
+        fn parse_tts(&self, s: @str) -> ~[ast::token_tree];
     }
 
     impl ExtParseUtils for ExtCtxt {
 
-        fn parse_item(&self, s: ~str) -> @ast::item {
+        fn parse_item(&self, s: @str) -> @ast::item {
             let res = parse::parse_item_from_source_str(
-                ~"<quote expansion>",
-                @(copy s),
+                @"<quote expansion>",
+                s,
                 self.cfg(),
                 ~[],
                 self.parse_sess());
@@ -341,27 +339,27 @@ pub mod rt {
             }
         }
 
-        fn parse_stmt(&self, s: ~str) -> @ast::stmt {
+        fn parse_stmt(&self, s: @str) -> @ast::stmt {
             parse::parse_stmt_from_source_str(
-                ~"<quote expansion>",
-                @(copy s),
+                @"<quote expansion>",
+                s,
                 self.cfg(),
                 ~[],
                 self.parse_sess())
         }
 
-        fn parse_expr(&self, s: ~str) -> @ast::expr {
+        fn parse_expr(&self, s: @str) -> @ast::expr {
             parse::parse_expr_from_source_str(
-                ~"<quote expansion>",
-                @(copy s),
+                @"<quote expansion>",
+                s,
                 self.cfg(),
                 self.parse_sess())
         }
 
-        fn parse_tts(&self, s: ~str) -> ~[ast::token_tree] {
+        fn parse_tts(&self, s: @str) -> ~[ast::token_tree] {
             parse::parse_tts_from_source_str(
-                ~"<quote expansion>",
-                @(copy s),
+                @"<quote expansion>",
+                s,
                 self.cfg(),
                 self.parse_sess())
         }
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 79018ebd1ea..d92f4e8458b 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -59,21 +59,21 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
 
     let topmost = topmost_expn_info(cx.backtrace().get());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
-    let filename = copy loc.file.name;
+    let filename = loc.file.name;
     base::MRExpr(cx.expr_str(topmost.call_site, filename))
 }
 
 pub fn expand_stringify(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     let s = pprust::tts_to_str(tts, get_ident_interner());
-    base::MRExpr(cx.expr_str(sp, s))
+    base::MRExpr(cx.expr_str(sp, s.to_managed()))
 }
 
 pub fn expand_mod(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "module_path!");
     base::MRExpr(cx.expr_str(sp,
-                             cx.mod_path().map(|x| cx.str_of(*x)).connect("::")))
+                             cx.mod_path().map(|x| cx.str_of(*x)).connect("::").to_managed()))
 }
 
 // include! : parse the given file as an expr
@@ -94,13 +94,13 @@ pub fn expand_include_str(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     let file = get_single_str_from_tts(cx, sp, tts, "include_str!");
     let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path(file)));
     match res {
-      result::Ok(_) => { /* Continue. */ }
-      result::Err(ref e) => {
-        cx.parse_sess().span_diagnostic.handler().fatal((*e));
+      result::Ok(res) => {
+          base::MRExpr(cx.expr_str(sp, res.to_managed()))
+      }
+      result::Err(e) => {
+        cx.span_fatal(sp, e);
       }
     }
-
-    base::MRExpr(cx.expr_str(sp, result::unwrap(res)))
 }
 
 pub fn expand_include_bin(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
@@ -131,7 +131,7 @@ fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
                             _
                         }) => {
                             // Don't recurse into file using "include!"
-                            if *name == ~"include" {
+                            if "include" == *name  {
                                 expn_info
                             } else {
                                 topmost_expn_info(next_expn_info)
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index e5a77cc21fb..dd155869526 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -205,7 +205,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match])
           } => {
             if ret_val.contains_key(bind_name) {
                 p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "+
-                                               *ident_to_str(bind_name))
+                                               ident_to_str(bind_name))
             }
             ret_val.insert(*bind_name, res[idx]);
           }
@@ -373,8 +373,8 @@ pub fn parse(
                 let nts = bb_eis.map(|ei| {
                     match ei.elts[ei.idx].node {
                       match_nonterminal(ref bind,ref name,_) => {
-                        fmt!("%s ('%s')", *ident_to_str(name),
-                             *ident_to_str(bind))
+                        fmt!("%s ('%s')", ident_to_str(name),
+                             ident_to_str(bind))
                       }
                       _ => fail!()
                     } }).connect(" or ");
@@ -398,7 +398,7 @@ pub fn parse(
                 match ei.elts[ei.idx].node {
                   match_nonterminal(_, ref name, idx) => {
                     ei.matches[idx].push(@matched_nonterminal(
-                        parse_nt(&rust_parser, *ident_to_str(name))));
+                        parse_nt(&rust_parser, ident_to_str(name))));
                     ei.idx += 1u;
                   }
                   _ => fail!()
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 7805e736467..491989c77c4 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -148,7 +148,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
         |cx, sp, arg| generic_extension(cx, sp, name, arg, *lhses, *rhses);
 
     return MRDef(MacroDef{
-        name: copy *ident_to_str(&name),
+        name: ident_to_str(&name),
         ext: NormalTT(base::SyntaxExpanderTT{expander: exp, span: Some(sp)})
     });
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index f3bd2d4b8d1..e44c3e67212 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -121,7 +121,7 @@ fn lookup_cur_matched(r: &mut TtReader, name: ident) -> @named_match {
         Some(s) => lookup_cur_matched_by_matched(r, s),
         None => {
             r.sp_diag.span_fatal(r.cur_span, fmt!("unknown macro variable `%s`",
-                                                  *ident_to_str(&name)));
+                                                  ident_to_str(&name)));
         }
     }
 }
@@ -139,8 +139,8 @@ fn lockstep_iter_size(t: &token_tree, r: &mut TtReader) -> lis {
             lis_contradiction(_) => copy rhs,
             lis_constraint(r_len, _) if l_len == r_len => copy lhs,
             lis_constraint(r_len, ref r_id) => {
-                let l_n = copy *ident_to_str(l_id);
-                let r_n = copy *ident_to_str(r_id);
+                let l_n = ident_to_str(l_id);
+                let r_n = ident_to_str(r_id);
                 lis_contradiction(fmt!("Inconsistent lockstep iteration: \
                                        '%s' has %u items, but '%s' has %u",
                                         l_n, l_len, r_n, r_len))
@@ -290,7 +290,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                 r.sp_diag.span_fatal(
                     copy r.cur_span, /* blame the macro writer */
                     fmt!("variable '%s' is still repeating at this depth",
-                         *ident_to_str(&ident)));
+                         ident_to_str(&ident)));
               }
             }
           }