diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc
index d043ee27fb1..f4ddcb72c9c 100644
--- a/src/libfuzzer/fuzzer.rc
+++ b/src/libfuzzer/fuzzer.rc
@@ -345,13 +345,13 @@ pub fn check_variants_T<T:Copy>(crate: @ast::crate,
                                             intr,
                                             span_handler,
                                             crate2,
-                                            fname.to_str(),
+                                            fname.to_managed(),
                                             rdr,
                                             a,
                                             pprust::no_ann(),
                                             false)
                     };
-                    @string
+                    string.to_managed()
                 };
                 match cx.mode {
                     tm_converge => check_roundtrip_convergence(str3, 1),
@@ -361,9 +361,9 @@ pub fn check_variants_T<T:Copy>(crate: @ast::crate,
                                               thing_label,
                                               i,
                                               j);
-                        let safe_to_run = !(content_is_dangerous_to_run(*str3)
+                        let safe_to_run = !(content_is_dangerous_to_run(str3)
                                             || has_raw_pointers(crate2));
-                        check_whole_compiler(*str3,
+                        check_whole_compiler(str3,
                                              &Path(file_label),
                                              safe_to_run);
                     }
@@ -502,15 +502,15 @@ pub fn check_compiling(filename: &Path) -> happiness {
 }
 
 
-pub fn parse_and_print(code: @~str) -> ~str {
+pub fn parse_and_print(code: @str) -> @str {
     let filename = Path("tmp.rs");
     let sess = parse::new_parse_sess(option::None);
-    write_file(&filename, *code);
-    let crate = parse::parse_crate_from_source_str(filename.to_str(),
+    write_file(&filename, code);
+    let crate = parse::parse_crate_from_source_str(filename.to_str().to_managed(),
                                                    code,
                                                    ~[],
                                                    sess);
-    do io::with_str_reader(*code) |rdr| {
+    do io::with_str_reader(code) |rdr| {
         let filename = filename.to_str();
         do as_str |a| {
             pprust::print_crate(sess.cm,
@@ -518,12 +518,12 @@ pub fn parse_and_print(code: @~str) -> ~str {
                                 token::mk_fake_ident_interner(),
                                 copy sess.span_diagnostic,
                                 crate,
-                                filename.to_str(),
+                                filename.to_managed(),
                                 rdr,
                                 a,
                                 pprust::no_ann(),
                                 false)
-        }
+        }.to_managed()
     }
 }
 
@@ -598,15 +598,15 @@ pub fn file_might_not_converge(filename: &Path) -> bool {
     return false;
 }
 
-pub fn check_roundtrip_convergence(code: @~str, maxIters: uint) {
+pub fn check_roundtrip_convergence(code: @str, maxIters: uint) {
     let mut i = 0u;
     let mut newv = code;
     let mut oldv = code;
 
     while i < maxIters {
         oldv = newv;
-        if content_might_not_converge(*oldv) { return; }
-        newv = @parse_and_print(oldv);
+        if content_might_not_converge(oldv) { return; }
+        newv = parse_and_print(oldv);
         if oldv == newv { break; }
         i += 1u;
     }
@@ -615,8 +615,8 @@ pub fn check_roundtrip_convergence(code: @~str, maxIters: uint) {
         error!("Converged after %u iterations", i);
     } else {
         error!("Did not converge after %u iterations!", i);
-        write_file(&Path("round-trip-a.rs"), *oldv);
-        write_file(&Path("round-trip-b.rs"), *newv);
+        write_file(&Path("round-trip-a.rs"), oldv);
+        write_file(&Path("round-trip-b.rs"), newv);
         run::process_status("diff", [~"-w", ~"-u", ~"round-trip-a.rs", ~"round-trip-b.rs"]);
         fail!("Mismatch");
     }
@@ -626,8 +626,8 @@ pub fn check_convergence(files: &[Path]) {
     error!("pp convergence tests: %u files", files.len());
     for files.each |file| {
         if !file_might_not_converge(file) {
-            let s = @result::get(&io::read_whole_file_str(file));
-            if !content_might_not_converge(*s) {
+            let s = result::get(&io::read_whole_file_str(file)).to_managed();
+            if !content_might_not_converge(s) {
                 error!("pp converge: %s", file.to_str());
                 // Change from 7u to 2u once
                 // https://github.com/mozilla/rust/issues/850 is fixed
@@ -646,14 +646,14 @@ pub fn check_variants(files: &[Path], cx: Context) {
             loop;
         }
 
-        let s = @result::get(&io::read_whole_file_str(file));
-        if contains(*s, "#") {
+        let s = result::get(&io::read_whole_file_str(file)).to_managed();
+        if s.contains_char('#') {
             loop; // Macros are confusing
         }
-        if cx.mode == tm_converge && content_might_not_converge(*s) {
+        if cx.mode == tm_converge && content_might_not_converge(s) {
             loop;
         }
-        if cx.mode == tm_run && content_is_dangerous_to_compile(*s) {
+        if cx.mode == tm_run && content_is_dangerous_to_compile(s) {
             loop;
         }
 
@@ -661,11 +661,11 @@ pub fn check_variants(files: &[Path], cx: Context) {
 
         error!("check_variants: %?", file_str);
         let sess = parse::new_parse_sess(None);
-        let crate = parse::parse_crate_from_source_str(file_str.to_str(),
+        let crate = parse::parse_crate_from_source_str(file_str.to_managed(),
                                                        s,
                                                        ~[],
                                                        sess);
-        io::with_str_reader(*s, |rdr| {
+        io::with_str_reader(s, |rdr| {
             let file_str = file_str.to_str();
             error!("%s",
                    as_str(|a| {
@@ -675,7 +675,7 @@ pub fn check_variants(files: &[Path], cx: Context) {
                         token::mk_fake_ident_interner(),
                         copy sess.span_diagnostic,
                         crate,
-                        file_str.to_str(),
+                        file_str.to_managed(),
                         rdr,
                         a,
                         pprust::no_ann(),
diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index 84fb361adb9..3934e946141 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -493,16 +493,16 @@ pub fn build_link_meta(sess: Session,
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess.diagnostic(), linkage_metas);
         for linkage_metas.each |meta| {
-            if *attr::get_meta_item_name(*meta) == ~"name" {
+            if "name" == attr::get_meta_item_name(*meta) {
                 match attr::get_meta_item_value_str(*meta) {
                   // Changing attr would avoid the need for the copy
                   // here
-                  Some(v) => { name = Some(v.to_managed()); }
+                  Some(v) => { name = Some(v); }
                   None => cmh_items.push(*meta)
                 }
-            } else if *attr::get_meta_item_name(*meta) == ~"vers" {
+            } else if "vers" == attr::get_meta_item_name(*meta) {
                 match attr::get_meta_item_value_str(*meta) {
-                  Some(v) => { vers = Some(v.to_managed()); }
+                  Some(v) => { vers = Some(v); }
                   None => cmh_items.push(*meta)
                 }
             } else { cmh_items.push(*meta); }
@@ -518,7 +518,7 @@ pub fn build_link_meta(sess: Session,
     // This calculates CMH as defined above
     fn crate_meta_extras_hash(symbol_hasher: &mut hash::State,
                               cmh_items: ~[@ast::meta_item],
-                              dep_hashes: ~[~str]) -> @str {
+                              dep_hashes: ~[@str]) -> @str {
         fn len_and_str(s: &str) -> ~str {
             fmt!("%u_%s", s.len(), s)
         }
@@ -532,14 +532,14 @@ pub fn build_link_meta(sess: Session,
         fn hash(symbol_hasher: &mut hash::State, m: &@ast::meta_item) {
             match m.node {
               ast::meta_name_value(key, value) => {
-                write_string(symbol_hasher, len_and_str(*key));
+                write_string(symbol_hasher, len_and_str(key));
                 write_string(symbol_hasher, len_and_str_lit(value));
               }
               ast::meta_word(name) => {
-                write_string(symbol_hasher, len_and_str(*name));
+                write_string(symbol_hasher, len_and_str(name));
               }
               ast::meta_list(name, ref mis) => {
-                write_string(symbol_hasher, len_and_str(*name));
+                write_string(symbol_hasher, len_and_str(name));
                 for mis.each |m_| {
                     hash(symbol_hasher, m_);
                 }
@@ -706,7 +706,7 @@ pub fn mangle(sess: Session, ss: path) -> ~str {
 
     for ss.each |s| {
         match *s { path_name(s) | path_mod(s) => {
-          let sani = sanitize(*sess.str_of(s));
+          let sani = sanitize(sess.str_of(s));
           n += fmt!("%u%s", sani.len(), sani);
         } }
     }
@@ -912,7 +912,7 @@ pub fn link_args(sess: Session,
     }
 
     let ula = cstore::get_used_link_args(cstore);
-    for ula.each |arg| { args.push(/*bad*/copy *arg); }
+    for ula.each |arg| { args.push(arg.to_owned()); }
 
     // Add all the link args for external crates.
     do cstore::iter_crate_data(cstore) |crate_num, _| {
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 4b7ab6fdfc1..0447481596a 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -55,31 +55,31 @@ pub enum pp_mode {
  * The name used for source code that doesn't originate in a file
  * (e.g. source from stdin or a string)
  */
-pub fn anon_src() -> ~str { ~"<anon>" }
+pub fn anon_src() -> @str { @"<anon>" }
 
-pub fn source_name(input: &input) -> ~str {
+pub fn source_name(input: &input) -> @str {
     match *input {
-      file_input(ref ifile) => ifile.to_str(),
+      file_input(ref ifile) => ifile.to_str().to_managed(),
       str_input(_) => anon_src()
     }
 }
 
-pub fn default_configuration(sess: Session, argv0: @~str, input: &input) ->
+pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::crate_cfg {
     let libc = match sess.targ_cfg.os {
-      session::os_win32 => ~"msvcrt.dll",
-      session::os_macos => ~"libc.dylib",
-      session::os_linux => ~"libc.so.6",
-      session::os_android => ~"libc.so",
-      session::os_freebsd => ~"libc.so.7"
+      session::os_win32 => @"msvcrt.dll",
+      session::os_macos => @"libc.dylib",
+      session::os_linux => @"libc.so.6",
+      session::os_android => @"libc.so",
+      session::os_freebsd => @"libc.so.7"
       // _ { "libc.so" }
     };
     let tos = match sess.targ_cfg.os {
-      session::os_win32 => ~"win32",
-      session::os_macos => ~"macos",
-      session::os_linux => ~"linux",
-      session::os_android => ~"android",
-      session::os_freebsd => ~"freebsd"
+      session::os_win32 => @"win32",
+      session::os_macos => @"macos",
+      session::os_linux => @"linux",
+      session::os_android => @"android",
+      session::os_freebsd => @"freebsd"
       // _ { "libc.so" }
     };
 
@@ -88,47 +88,47 @@ pub fn default_configuration(sess: Session, argv0: @~str, input: &input) ->
     // ARM is bi-endian, however using NDK seems to default
     // to little-endian unless a flag is provided.
     let (end,arch,wordsz) = match sess.targ_cfg.arch {
-        abi::X86 => (~"little",~"x86",~"32"),
-        abi::X86_64 => (~"little",~"x86_64",~"64"),
-        abi::Arm => (~"little",~"arm",~"32"),
-        abi::Mips => (~"big",~"mips",~"32")
+        abi::X86 => (@"little",@"x86",@"32"),
+        abi::X86_64 => (@"little",@"x86_64",@"64"),
+        abi::Arm => (@"little",@"arm",@"32"),
+        abi::Mips => (@"big",@"mips",@"32")
     };
 
     return ~[ // Target bindings.
-         attr::mk_word_item(@os::FAMILY.to_owned()),
-         mk(@~"target_os", @tos),
-         mk(@~"target_family", @os::FAMILY.to_owned()),
-         mk(@~"target_arch", @arch),
-         mk(@~"target_endian", @end),
-         mk(@~"target_word_size", @wordsz),
-         mk(@~"target_libc", @libc),
+         attr::mk_word_item(os::FAMILY.to_managed()),
+         mk(@"target_os", tos),
+         mk(@"target_family", os::FAMILY.to_managed()),
+         mk(@"target_arch", arch),
+         mk(@"target_endian", end),
+         mk(@"target_word_size", wordsz),
+         mk(@"target_libc", libc),
          // Build bindings.
-         mk(@~"build_compiler", argv0),
-         mk(@~"build_input", @source_name(input))];
+         mk(@"build_compiler", argv0),
+         mk(@"build_input", source_name(input))];
 }
 
-pub fn append_configuration(cfg: ast::crate_cfg, name: ~str)
+pub fn append_configuration(cfg: ast::crate_cfg, name: @str)
                          -> ast::crate_cfg {
     if attr::contains_name(cfg, name) {
         cfg
     } else {
-        vec::append_one(cfg, attr::mk_word_item(@name))
+        vec::append_one(cfg, attr::mk_word_item(name))
     }
 }
 
-pub fn build_configuration(sess: Session, argv0: @~str, input: &input) ->
+pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::crate_cfg {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
     let default_cfg = default_configuration(sess, argv0, input);
     let user_cfg = /*bad*/copy sess.opts.cfg;
     // If the user wants a test runner, then add the test cfg
-    let user_cfg = if sess.opts.test { append_configuration(user_cfg, ~"test") }
+    let user_cfg = if sess.opts.test { append_configuration(user_cfg, @"test") }
                    else { user_cfg };
     // If the user requested GC, then add the GC cfg
     let user_cfg = append_configuration(
         user_cfg,
-        if sess.opts.gc { ~"gc" } else { ~"nogc" });
+        if sess.opts.gc { @"gc" } else { @"nogc" });
     return vec::append(user_cfg, default_cfg);
 }
 
@@ -137,7 +137,7 @@ fn parse_cfgspecs(cfgspecs: ~[~str],
                   demitter: diagnostic::Emitter) -> ast::crate_cfg {
     do vec::map_consume(cfgspecs) |s| {
         let sess = parse::new_parse_sess(Some(demitter));
-        parse::parse_meta_from_source_str(~"cfgspec", @s, ~[], sess)
+        parse::parse_meta_from_source_str(@"cfgspec", s.to_managed(), ~[], sess)
     }
 }
 
@@ -145,7 +145,8 @@ pub enum input {
     /// Load source from file
     file_input(Path),
     /// The string is the source
-    str_input(~str)
+    // FIXME (#2319): Don't really want to box the source string
+    str_input(@str)
 }
 
 pub fn parse_input(sess: Session, cfg: ast::crate_cfg, input: &input)
@@ -154,10 +155,9 @@ pub fn parse_input(sess: Session, cfg: ast::crate_cfg, input: &input)
       file_input(ref file) => {
         parse::parse_crate_from_file(&(*file), cfg, sess.parse_sess)
       }
-      str_input(ref src) => {
-        // FIXME (#2319): Don't really want to box the source string
+      str_input(src) => {
         parse::parse_crate_from_source_str(
-            anon_src(), @(/*bad*/copy *src), cfg, sess.parse_sess)
+            anon_src(), src, cfg, sess.parse_sess)
       }
     }
 }
@@ -455,7 +455,7 @@ pub fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: &input,
     };
     let is_expanded = upto != cu_parse;
     let src = sess.codemap.get_filemap(source_name(input)).src;
-    do io::with_str_reader(*src) |rdr| {
+    do io::with_str_reader(src) |rdr| {
         pprust::print_crate(sess.codemap, token::get_ident_interner(),
                             sess.span_diagnostic, crate.unwrap(),
                             source_name(input),
@@ -566,7 +566,7 @@ pub fn host_triple() -> ~str {
         };
 }
 
-pub fn build_session_options(binary: @~str,
+pub fn build_session_options(binary: @str,
                              matches: &getopts::Matches,
                              demitter: diagnostic::Emitter)
                           -> @session::options {
@@ -595,7 +595,7 @@ pub fn build_session_options(binary: @~str,
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
             let lint_name = lint_name.replace("-", "_");
-            match lint_dict.find(&lint_name) {
+            match lint_dict.find_equiv(&lint_name) {
               None => {
                 early_error(demitter, fmt!("unknown %s flag: %s",
                                            level_name, lint_name));
@@ -895,8 +895,8 @@ pub fn build_output_filenames(input: &input,
           };
 
           let mut stem = match *input {
-              file_input(ref ifile) => (*ifile).filestem().get(),
-              str_input(_) => ~"rust_out"
+              file_input(ref ifile) => (*ifile).filestem().get().to_managed(),
+              str_input(_) => @"rust_out"
           };
 
           // If a linkage name meta is present, we use it as the link name
@@ -906,7 +906,7 @@ pub fn build_output_filenames(input: &input,
               let maybe_matches = attr::find_meta_items_by_name(linkage_metas, "name");
               if !maybe_matches.is_empty() {
                   match attr::get_meta_item_value_str(maybe_matches[0]) {
-                      Some(s) => stem = copy *s,
+                      Some(s) => stem = s,
                       _ => ()
                   }
               }
@@ -982,9 +982,9 @@ mod test {
               Err(f) => fail!("test_switch_implies_cfg_test: %s", getopts::fail_str(f))
             };
         let sessopts = build_session_options(
-            @~"rustc", matches, diagnostic::emit);
+            @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess, @~"whatever", &str_input(~""));
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         assert!((attr::contains_name(cfg, "test")));
     }
 
@@ -1000,9 +1000,9 @@ mod test {
               }
             };
         let sessopts = build_session_options(
-            @~"rustc", matches, diagnostic::emit);
+            @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess, @~"whatever", &str_input(~""));
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         let test_items = attr::find_meta_items_by_name(cfg, "test");
         assert_eq!(test_items.len(), 1u);
     }
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
index 211665942a8..73e8cfea8ca 100644
--- a/src/librustc/driver/session.rs
+++ b/src/librustc/driver/session.rs
@@ -150,7 +150,7 @@ pub struct options {
     // will be added to the crate AST node.  This should not be used for
     // anything except building the full crate config prior to parsing.
     cfg: ast::crate_cfg,
-    binary: @~str,
+    binary: @str,
     test: bool,
     parse_only: bool,
     no_trans: bool,
@@ -295,7 +295,7 @@ impl Session_ {
     }
 
     // pointless function, now...
-    pub fn str_of(@self, id: ast::ident) -> @~str {
+    pub fn str_of(@self, id: ast::ident) -> @str {
         token::ident_to_str(&id)
     }
 
@@ -331,7 +331,7 @@ pub fn basic_options() -> @options {
         target_triple: host_triple(),
         target_feature: ~"",
         cfg: ~[],
-        binary: @~"rustc",
+        binary: @"rustc",
         test: false,
         parse_only: false,
         no_trans: false,
@@ -361,7 +361,7 @@ pub fn building_library(req_crate_type: crate_type,
             match syntax::attr::first_attr_value_str_by_name(
                 crate.node.attrs,
                 "crate_type") {
-              Some(@~"lib") => true,
+              Some(s) if "lib" == s => true,
               _ => false
             }
         }
@@ -389,22 +389,22 @@ mod test {
     use syntax::ast;
     use syntax::codemap;
 
-    fn make_crate_type_attr(t: ~str) -> ast::attribute {
+    fn make_crate_type_attr(t: @str) -> ast::attribute {
         codemap::respan(codemap::dummy_sp(), ast::attribute_ {
             style: ast::attr_outer,
             value: @codemap::respan(codemap::dummy_sp(),
                 ast::meta_name_value(
-                    @~"crate_type",
+                    @"crate_type",
                     codemap::respan(codemap::dummy_sp(),
-                                     ast::lit_str(@t)))),
+                                     ast::lit_str(t)))),
             is_sugared_doc: false
         })
     }
 
     fn make_crate(with_bin: bool, with_lib: bool) -> @ast::crate {
         let mut attrs = ~[];
-        if with_bin { attrs += [make_crate_type_attr(~"bin")]; }
-        if with_lib { attrs += [make_crate_type_attr(~"lib")]; }
+        if with_bin { attrs += [make_crate_type_attr(@"bin")]; }
+        if with_lib { attrs += [make_crate_type_attr(@"lib")]; }
         @codemap::respan(codemap::dummy_sp(), ast::crate_ {
             module: ast::_mod { view_items: ~[], items: ~[] },
             attrs: attrs,
diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs
index b942bcf4b95..3e6ac283da0 100644
--- a/src/librustc/front/config.rs
+++ b/src/librustc/front/config.rs
@@ -202,7 +202,7 @@ pub fn metas_in_cfg(cfg: ast::crate_cfg,
     cfg_metas.any(|cfg_meta| {
         cfg_meta.all(|cfg_mi| {
             match cfg_mi.node {
-                ast::meta_list(s, ref it) if *s == ~"not"
+                ast::meta_list(s, ref it) if "not" == s
                     => it.all(|mi| !attr::contains(cfg, *mi)),
                 _ => attr::contains(cfg, *cfg_mi)
             }
diff --git a/src/librustc/front/intrinsic_inject.rs b/src/librustc/front/intrinsic_inject.rs
index 2cdfd17c169..0caadc8572e 100644
--- a/src/librustc/front/intrinsic_inject.rs
+++ b/src/librustc/front/intrinsic_inject.rs
@@ -17,9 +17,9 @@ use syntax::ast;
 use syntax::codemap::spanned;
 
 pub fn inject_intrinsic(sess: Session, crate: @ast::crate) -> @ast::crate {
-    let intrinsic_module = @(include_str!("intrinsic.rs").to_owned());
+    let intrinsic_module = include_str!("intrinsic.rs").to_managed();
 
-    let item = parse::parse_item_from_source_str(~"<intrinsic>",
+    let item = parse::parse_item_from_source_str(@"<intrinsic>",
                                                  intrinsic_module,
                                                  /*bad*/copy sess.opts.cfg,
                                                  ~[],
diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs
index a05dfc446ec..38a21af65b9 100644
--- a/src/librustc/front/std_inject.rs
+++ b/src/librustc/front/std_inject.rs
@@ -49,8 +49,8 @@ fn inject_libstd_ref(sess: Session, crate: @ast::crate) -> @ast::crate {
                     spanned(ast::attribute_ {
                         style: ast::attr_inner,
                         value: @spanned(ast::meta_name_value(
-                            @~"vers",
-                            spanned(ast::lit_str(@STD_VERSION.to_str()))
+                            @"vers",
+                            spanned(ast::lit_str(STD_VERSION.to_managed()))
                         )),
                         is_sugared_doc: false
                     })
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index c05e2a85bc7..de6fc322c63 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -52,7 +52,7 @@ pub fn modify_for_testing(sess: session::Session,
     // configuration, either with the '--test' or '--cfg test'
     // command line options.
     let should_test = attr::contains(crate.node.config,
-                                     attr::mk_word_item(@~"test"));
+                                     attr::mk_word_item(@"test"));
 
     if should_test {
         generate_test_harness(sess, crate)
@@ -76,7 +76,7 @@ fn generate_test_harness(sess: session::Session,
     ext_cx.bt_push(ExpandedFrom(CallInfo {
         call_site: dummy_sp(),
         callee: NameAndSpan {
-            name: ~"test",
+            name: @"test",
             span: None
         }
     }));
@@ -111,7 +111,7 @@ fn fold_mod(cx: @mut TestCtxt,
     fn nomain(cx: @mut TestCtxt, item: @ast::item) -> @ast::item {
         if !*cx.sess.building_library {
             @ast::item{attrs: item.attrs.filtered(|attr| {
-                               *attr::get_attr_name(attr) != ~"main"
+                               "main" != attr::get_attr_name(attr)
                            }),.. copy *item}
         } else { item }
     }
@@ -272,9 +272,9 @@ mod __test {
 */
 
 fn mk_std(cx: &TestCtxt) -> @ast::view_item {
-    let vers = ast::lit_str(@~"0.7-pre");
+    let vers = ast::lit_str(@"0.7-pre");
     let vers = nospan(vers);
-    let mi = ast::meta_name_value(@~"vers", vers);
+    let mi = ast::meta_name_value(@"vers", vers);
     let mi = nospan(mi);
     let id_std = cx.sess.ident_of("extra");
     let vi = if is_std(cx) {
@@ -321,7 +321,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
 
     // This attribute tells resolve to let us call unexported functions
     let resolve_unexported_attr =
-        attr::mk_attr(attr::mk_word_item(@~"!resolve_unexported"));
+        attr::mk_attr(attr::mk_word_item(@"!resolve_unexported"));
 
     let item = ast::item {
         ident: cx.sess.ident_of("__test"),
@@ -376,7 +376,7 @@ fn is_std(cx: &TestCtxt) -> bool {
     let is_std = {
         let items = attr::find_linkage_metas(cx.crate.node.attrs);
         match attr::last_meta_item_value_str_by_name(items, "name") {
-          Some(@~"extra") => true,
+          Some(s) if "extra" == s => true,
           _ => false
         }
     };
@@ -413,7 +413,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::expr {
     debug!("encoding %s", ast_util::path_name_i(path));
 
     let name_lit: ast::lit =
-        nospan(ast::lit_str(@ast_util::path_name_i(path)));
+        nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
 
     let name_expr = @ast::expr {
           id: cx.sess.next_node_id(),
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index e05684d51e2..e95c841b9f7 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -60,7 +60,7 @@ pub fn read_crates(diag: @span_handler,
 struct cache_entry {
     cnum: int,
     span: span,
-    hash: @~str,
+    hash: @str,
     metas: @~[@ast::meta_item]
 }
 
@@ -100,12 +100,12 @@ fn warn_if_multiple_versions(e: @mut Env,
 
         if matches.len() != 1u {
             diag.handler().warn(
-                fmt!("using multiple versions of crate `%s`", *name));
+                fmt!("using multiple versions of crate `%s`", name));
             for matches.each |match_| {
                 diag.span_note(match_.span, "used here");
                 let attrs = ~[
                     attr::mk_attr(attr::mk_list_item(
-                        @~"link", /*bad*/copy *match_.metas))
+                        @"link", /*bad*/copy *match_.metas))
                 ];
                 loader::note_linkage_attrs(e.intr, diag, attrs);
             }
@@ -133,7 +133,7 @@ fn visit_crate(e: @mut Env, c: &ast::crate) {
     for link_args.each |a| {
         match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
           Some(ref linkarg) => {
-            cstore::add_used_link_args(cstore, **linkarg);
+            cstore::add_used_link_args(cstore, *linkarg);
           }
           None => {/* fallthrough */ }
         }
@@ -145,7 +145,7 @@ fn visit_view_item(e: @mut Env, i: @ast::view_item) {
       ast::view_item_extern_mod(ident, ref meta_items, id) => {
         debug!("resolving extern mod stmt. ident: %?, meta: %?",
                ident, *meta_items);
-        let cnum = resolve_crate(e, ident, copy *meta_items, @~"", i.span);
+        let cnum = resolve_crate(e, ident, copy *meta_items, @"", i.span);
         cstore::add_extern_mod_stmt_cnum(e.cstore, id, cnum);
       }
       _ => ()
@@ -169,7 +169,7 @@ fn visit_item(e: @mut Env, i: @ast::item) {
                     match attr::first_attr_value_str_by_name(i.attrs,
                                                              "link_name") {
                         Some(nn) => {
-                            if *nn == ~"" {
+                            if nn.is_empty() {
                                 e.diag.span_fatal(
                                     i.span,
                                     "empty #[link_name] not allowed; use \
@@ -184,7 +184,7 @@ fn visit_item(e: @mut Env, i: @ast::item) {
                         !cstore::add_used_library(cstore, foreign_name);
                 }
                 if !link_args.is_empty() && already_added {
-                    e.diag.span_fatal(i.span, ~"library '" + *foreign_name +
+                    e.diag.span_fatal(i.span, ~"library '" + foreign_name +
                                "' already added: can't specify link_args.");
                 }
             }
@@ -194,7 +194,7 @@ fn visit_item(e: @mut Env, i: @ast::item) {
         for link_args.each |a| {
             match attr::get_meta_item_value_str(attr::attr_meta(*a)) {
                 Some(linkarg) => {
-                    cstore::add_used_link_args(cstore, *linkarg);
+                    cstore::add_used_link_args(cstore, linkarg);
                 }
                 None => { /* fallthrough */ }
             }
@@ -204,9 +204,9 @@ fn visit_item(e: @mut Env, i: @ast::item) {
     }
 }
 
-fn metas_with(ident: @~str, key: @~str, metas: ~[@ast::meta_item])
+fn metas_with(ident: @str, key: @str, metas: ~[@ast::meta_item])
     -> ~[@ast::meta_item] {
-    let name_items = attr::find_meta_items_by_name(metas, *key);
+    let name_items = attr::find_meta_items_by_name(metas, key);
     if name_items.is_empty() {
         vec::append_one(metas, attr::mk_name_value_item_str(key, ident))
     } else {
@@ -214,12 +214,12 @@ fn metas_with(ident: @~str, key: @~str, metas: ~[@ast::meta_item])
     }
 }
 
-fn metas_with_ident(ident: @~str, metas: ~[@ast::meta_item])
+fn metas_with_ident(ident: @str, metas: ~[@ast::meta_item])
     -> ~[@ast::meta_item] {
-    metas_with(ident, @~"name", metas)
+    metas_with(ident, @"name", metas)
 }
 
-fn existing_match(e: @mut Env, metas: &[@ast::meta_item], hash: @~str)
+fn existing_match(e: @mut Env, metas: &[@ast::meta_item], hash: @str)
                -> Option<int> {
     for e.crate_cache.each |c| {
         if loader::metadata_matches(*c.metas, metas)
@@ -233,7 +233,7 @@ fn existing_match(e: @mut Env, metas: &[@ast::meta_item], hash: @~str)
 fn resolve_crate(e: @mut Env,
                  ident: ast::ident,
                  metas: ~[@ast::meta_item],
-                 hash: @~str,
+                 hash: @str,
                  span: span)
               -> ast::crate_num {
     let metas = metas_with_ident(token::ident_to_str(&ident), metas);
@@ -307,9 +307,9 @@ fn resolve_crate_deps(e: @mut Env, cdata: @~[u8]) -> cstore::cnum_map {
         let extrn_cnum = dep.cnum;
         let cname = dep.name;
         let cname_str = token::ident_to_str(&dep.name);
-        let cmetas = metas_with(dep.vers, @~"vers", ~[]);
+        let cmetas = metas_with(dep.vers, @"vers", ~[]);
         debug!("resolving dep crate %s ver: %s hash: %s",
-               *cname_str, *dep.vers, *dep.hash);
+               cname_str, dep.vers, dep.hash);
         match existing_match(e, metas_with_ident(cname_str,
                                                  copy cmetas),
                              dep.hash) {
diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index 955f07ed9c3..5b154f6836c 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -74,7 +74,7 @@ pub fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
     // FIXME #1920: This path is not always correct if the crate is not linked
     // into the root namespace.
     vec::append(~[ast_map::path_mod(tcx.sess.ident_of(
-        *cdata.name))], path)
+        cdata.name))], path)
 }
 
 pub enum found_ast {
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index f0cabe50455..71061d91540 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -31,7 +31,7 @@ use syntax::parse::token::ident_interner;
 pub type cnum_map = @mut HashMap<ast::crate_num, ast::crate_num>;
 
 pub struct crate_metadata {
-    name: @~str,
+    name: @str,
     data: @~[u8],
     cnum_map: cnum_map,
     cnum: ast::crate_num
@@ -41,8 +41,8 @@ pub struct CStore {
     priv metas: HashMap <ast::crate_num, @crate_metadata>,
     priv extern_mod_crate_map: extern_mod_crate_map,
     priv used_crate_files: ~[Path],
-    priv used_libraries: ~[~str],
-    priv used_link_args: ~[~str],
+    priv used_libraries: ~[@str],
+    priv used_link_args: ~[@str],
     intr: @ident_interner
 }
 
@@ -65,12 +65,12 @@ pub fn get_crate_data(cstore: &CStore, cnum: ast::crate_num)
     return *cstore.metas.get(&cnum);
 }
 
-pub fn get_crate_hash(cstore: &CStore, cnum: ast::crate_num) -> @~str {
+pub fn get_crate_hash(cstore: &CStore, cnum: ast::crate_num) -> @str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_hash(cdata.data)
 }
 
-pub fn get_crate_vers(cstore: &CStore, cnum: ast::crate_num) -> @~str {
+pub fn get_crate_vers(cstore: &CStore, cnum: ast::crate_num) -> @str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_vers(cdata.data)
 }
@@ -102,26 +102,28 @@ pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] {
     return /*bad*/copy cstore.used_crate_files;
 }
 
-pub fn add_used_library(cstore: &mut CStore, lib: @~str) -> bool {
-    assert!(*lib != ~"");
+pub fn add_used_library(cstore: &mut CStore, lib: @str) -> bool {
+    assert!(!lib.is_empty());
 
-    if cstore.used_libraries.contains(&*lib) { return false; }
-    cstore.used_libraries.push(/*bad*/ copy *lib);
+    if cstore.used_libraries.contains(&lib) { return false; }
+    cstore.used_libraries.push(lib);
     true
 }
 
-pub fn get_used_libraries(cstore: &CStore) -> ~[~str] {
-    /*bad*/copy cstore.used_libraries
+pub fn get_used_libraries<'a>(cstore: &'a CStore) -> &'a [@str] {
+    let slice: &'a [@str] = cstore.used_libraries;
+    slice
 }
 
 pub fn add_used_link_args(cstore: &mut CStore, args: &str) {
     for args.split_iter(' ').advance |s| {
-        cstore.used_link_args.push(s.to_owned());
+        cstore.used_link_args.push(s.to_managed());
     }
 }
 
-pub fn get_used_link_args(cstore: &CStore) -> ~[~str] {
-    /*bad*/copy cstore.used_link_args
+pub fn get_used_link_args<'a>(cstore: &'a CStore) -> &'a [@str] {
+    let slice: &'a [@str] = cstore.used_link_args;
+    slice
 }
 
 pub fn add_extern_mod_stmt_cnum(cstore: &mut CStore,
@@ -138,15 +140,15 @@ pub fn find_extern_mod_stmt_cnum(cstore: &CStore,
 
 // returns hashes of crates directly used by this crate. Hashes are sorted by
 // (crate name, crate version, crate hash) in lexicographic order (not semver)
-pub fn get_dep_hashes(cstore: &CStore) -> ~[~str] {
-    struct crate_hash { name: @~str, vers: @~str, hash: @~str }
+pub fn get_dep_hashes(cstore: &CStore) -> ~[@str] {
+    struct crate_hash { name: @str, vers: @str, hash: @str }
     let mut result = ~[];
 
     for cstore.extern_mod_crate_map.each_value |&cnum| {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
         let vers = decoder::get_crate_vers(cdata.data);
-        debug!("Add hash[%s]: %s %s", *cdata.name, *vers, *hash);
+        debug!("Add hash[%s]: %s %s", cdata.name, vers, hash);
         result.push(crate_hash {
             name: cdata.name,
             vers: vers,
@@ -160,8 +162,8 @@ pub fn get_dep_hashes(cstore: &CStore) -> ~[~str] {
 
     debug!("sorted:");
     for sorted.each |x| {
-        debug!("  hash[%s]: %s", *x.name, *x.hash);
+        debug!("  hash[%s]: %s", x.name, x.hash);
     }
 
-    sorted.map(|ch| /*bad*/copy *ch.hash)
+    sorted.map(|ch| ch.hash)
 }
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 980d318ec62..bea0eeb1f25 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -36,7 +36,7 @@ use extra::serialize::Decodable;
 use syntax::ast_map;
 use syntax::attr;
 use syntax::diagnostic::span_handler;
-use syntax::parse::token::{StringRef, ident_interner, special_idents};
+use syntax::parse::token::{ident_interner, special_idents};
 use syntax::print::pprust;
 use syntax::{ast, ast_util};
 use syntax::codemap;
@@ -311,7 +311,7 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path {
 fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
     let name = reader::get_doc(item, tag_paths_data_name);
     let string = name.as_str_slice();
-    match intr.find_equiv(&StringRef(string)) {
+    match intr.find_equiv(&string) {
         None => token::str_to_ident(string),
         Some(val) => ast::new_ident(val),
     }
@@ -985,23 +985,23 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
     let mut items: ~[@ast::meta_item] = ~[];
     for reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = nd.as_str();
-        items.push(attr::mk_word_item(@n));
+        let n = nd.as_str_slice().to_managed();
+        items.push(attr::mk_word_item(n));
     };
     for reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = nd.as_str();
-        let v = vd.as_str();
+        let n = nd.as_str_slice().to_managed();
+        let v = vd.as_str_slice().to_managed();
         // FIXME (#623): Should be able to decode meta_name_value variants,
         // but currently the encoder just drops them
-        items.push(attr::mk_name_value_item_str(@n, @v));
+        items.push(attr::mk_name_value_item_str(n, v));
     };
     for reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
         let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = nd.as_str();
+        let n = nd.as_str_slice().to_managed();
         let subitems = get_meta_items(meta_item_doc);
-        items.push(attr::mk_list_item(@n, subitems));
+        items.push(attr::mk_list_item(n, subitems));
     };
     return items;
 }
@@ -1058,8 +1058,8 @@ pub fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
 pub struct crate_dep {
     cnum: ast::crate_num,
     name: ast::ident,
-    vers: @~str,
-    hash: @~str
+    vers: @str,
+    hash: @str
 }
 
 pub fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] {
@@ -1067,14 +1067,15 @@ pub fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] {
     let cratedoc = reader::Doc(data);
     let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
     let mut crate_num = 1;
-    fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
-        reader::get_doc(doc, tag_).as_str()
+    fn docstr(doc: ebml::Doc, tag_: uint) -> @str {
+        let d = reader::get_doc(doc, tag_);
+        d.as_str_slice().to_managed()
     }
     for reader::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
         deps.push(crate_dep {cnum: crate_num,
                   name: token::str_to_ident(docstr(depdoc, tag_crate_dep_name)),
-                  vers: @docstr(depdoc, tag_crate_dep_vers),
-                  hash: @docstr(depdoc, tag_crate_dep_hash)});
+                  vers: docstr(depdoc, tag_crate_dep_vers),
+                  hash: docstr(depdoc, tag_crate_dep_hash)});
         crate_num += 1;
     };
     return deps;
@@ -1086,25 +1087,25 @@ fn list_crate_deps(data: @~[u8], out: @io::Writer) {
     for get_crate_deps(data).each |dep| {
         out.write_str(
             fmt!("%d %s-%s-%s\n",
-                 dep.cnum, *token::ident_to_str(&dep.name), *dep.hash, *dep.vers));
+                 dep.cnum, token::ident_to_str(&dep.name), dep.hash, dep.vers));
     }
 
     out.write_str("\n");
 }
 
-pub fn get_crate_hash(data: @~[u8]) -> @~str {
+pub fn get_crate_hash(data: @~[u8]) -> @str {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
-    @hashdoc.as_str()
+    hashdoc.as_str_slice().to_managed()
 }
 
-pub fn get_crate_vers(data: @~[u8]) -> @~str {
+pub fn get_crate_vers(data: @~[u8]) -> @str {
     let attrs = decoder::get_crate_attributes(data);
     let linkage_attrs = attr::find_linkage_metas(attrs);
 
     match attr::last_meta_item_value_str_by_name(linkage_attrs, "vers") {
         Some(ver) => ver,
-        None => @~"0.0"
+        None => @"0.0"
     }
 }
 
@@ -1126,7 +1127,7 @@ pub fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8],
                            out: @io::Writer) {
     let hash = get_crate_hash(bytes);
     let md = reader::Doc(bytes);
-    list_crate_attributes(intr, md, *hash, out);
+    list_crate_attributes(intr, md, hash, out);
     list_crate_deps(bytes, out);
 }
 
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 0c6c1065dba..45a7c457a4c 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -62,7 +62,7 @@ pub struct EncodeParams {
     reachable: reachable::map,
     reexports2: middle::resolve::ExportMap2,
     item_symbols: @mut HashMap<ast::node_id, ~str>,
-    discrim_symbols: @mut HashMap<ast::node_id, @~str>,
+    discrim_symbols: @mut HashMap<ast::node_id, @str>,
     link_meta: LinkMeta,
     cstore: @mut cstore::CStore,
     encode_inlined_item: encode_inlined_item
@@ -89,7 +89,7 @@ pub struct EncodeContext {
     reachable: reachable::map,
     reexports2: middle::resolve::ExportMap2,
     item_symbols: @mut HashMap<ast::node_id, ~str>,
-    discrim_symbols: @mut HashMap<ast::node_id, @~str>,
+    discrim_symbols: @mut HashMap<ast::node_id, @str>,
     link_meta: LinkMeta,
     cstore: @mut cstore::CStore,
     encode_inlined_item: encode_inlined_item,
@@ -103,14 +103,14 @@ pub fn reachable(ecx: @EncodeContext, id: node_id) -> bool {
 fn encode_name(ecx: @EncodeContext,
                ebml_w: &mut writer::Encoder,
                name: ident) {
-    ebml_w.wr_tagged_str(tag_paths_data_name, *ecx.tcx.sess.str_of(name));
+    ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name));
 }
 
 fn encode_impl_type_basename(ecx: @EncodeContext,
                              ebml_w: &mut writer::Encoder,
                              name: ident) {
     ebml_w.wr_tagged_str(tag_item_impl_type_basename,
-                         *ecx.tcx.sess.str_of(name));
+                         ecx.tcx.sess.str_of(name));
 }
 
 pub fn encode_def_id(ebml_w: &mut writer::Encoder, id: def_id) {
@@ -362,7 +362,7 @@ fn encode_path(ecx: @EncodeContext,
           ast_map::path_name(name) => (tag_path_elt_name, name)
         };
 
-        ebml_w.wr_tagged_str(tag, *ecx.tcx.sess.str_of(name));
+        ebml_w.wr_tagged_str(tag, ecx.tcx.sess.str_of(name));
     }
 
     ebml_w.start_tag(tag_path);
@@ -380,13 +380,13 @@ fn encode_reexported_static_method(ecx: @EncodeContext,
                                    method_def_id: def_id,
                                    method_ident: ident) {
     debug!("(encode reexported static method) %s::%s",
-            *exp.name, *ecx.tcx.sess.str_of(method_ident));
+            exp.name, ecx.tcx.sess.str_of(method_ident));
     ebml_w.start_tag(tag_items_data_item_reexport);
     ebml_w.start_tag(tag_items_data_item_reexport_def_id);
     ebml_w.wr_str(def_to_str(method_def_id));
     ebml_w.end_tag();
     ebml_w.start_tag(tag_items_data_item_reexport_name);
-    ebml_w.wr_str(*exp.name + "::" + *ecx.tcx.sess.str_of(method_ident));
+    ebml_w.wr_str(fmt!("%s::%s", exp.name, ecx.tcx.sess.str_of(method_ident)));
     ebml_w.end_tag();
     ebml_w.end_tag();
 }
@@ -449,17 +449,17 @@ fn encode_reexported_static_methods(ecx: @EncodeContext,
             // encoded metadata for static methods relative to Bar,
             // but not yet for Foo.
             //
-            if mod_path != *path || *exp.name != *original_name {
+            if mod_path != *path || exp.name != original_name {
                 if !encode_reexported_static_base_methods(ecx, ebml_w, exp) {
                     if encode_reexported_static_trait_methods(ecx, ebml_w, exp) {
                         debug!(fmt!("(encode reexported static methods) %s \
                                     [trait]",
-                                    *original_name));
+                                    original_name));
                     }
                 }
                 else {
                     debug!(fmt!("(encode reexported static methods) %s [base]",
-                                *original_name));
+                                original_name));
                 }
             }
         }
@@ -486,7 +486,7 @@ fn encode_info_for_mod(ecx: @EncodeContext,
                 let (ident, did) = (item.ident, item.id);
                 debug!("(encoding info for module) ... encoding impl %s \
                         (%?/%?)",
-                        *ecx.tcx.sess.str_of(ident),
+                        ecx.tcx.sess.str_of(ident),
                         did,
                         ast_map::node_id_to_str(ecx.tcx.items, did, token::get_ident_interner()));
 
@@ -507,13 +507,13 @@ fn encode_info_for_mod(ecx: @EncodeContext,
             debug!("(encoding info for module) found reexports for %d", id);
             for exports.each |exp| {
                 debug!("(encoding info for module) reexport '%s' for %d",
-                       *exp.name, id);
+                       exp.name, id);
                 ebml_w.start_tag(tag_items_data_item_reexport);
                 ebml_w.start_tag(tag_items_data_item_reexport_def_id);
                 ebml_w.wr_str(def_to_str(exp.def_id));
                 ebml_w.end_tag();
                 ebml_w.start_tag(tag_items_data_item_reexport_name);
-                ebml_w.wr_str(*exp.name);
+                ebml_w.wr_str(exp.name);
                 ebml_w.end_tag();
                 ebml_w.end_tag();
                 encode_reexported_static_methods(ecx, ebml_w, path, exp);
@@ -622,7 +622,7 @@ fn encode_info_for_struct(ecx: @EncodeContext,
         global_index.push(entry {val: id, pos: ebml_w.writer.tell()});
         ebml_w.start_tag(tag_items_data_item);
         debug!("encode_info_for_struct: doing %s %d",
-               *tcx.sess.str_of(nm), id);
+               tcx.sess.str_of(nm), id);
         encode_struct_field_family(ebml_w, vis);
         encode_name(ecx, ebml_w, nm);
         encode_path(ecx, ebml_w, path, ast_map::path_name(nm));
@@ -648,7 +648,7 @@ fn encode_info_for_ctor(ecx: @EncodeContext,
         encode_type_param_bounds(ebml_w, ecx, &generics.ty_params);
         let its_ty = node_id_to_type(ecx.tcx, id);
         debug!("fn name = %s ty = %s its node id = %d",
-               *ecx.tcx.sess.str_of(ident),
+               ecx.tcx.sess.str_of(ident),
                ty_to_str(ecx.tcx, its_ty), id);
         encode_type(ecx, ebml_w, its_ty);
         encode_path(ecx, ebml_w, path, ast_map::path_name(ident));
@@ -708,7 +708,7 @@ fn encode_info_for_method(ecx: @EncodeContext,
                           owner_generics: &ast::Generics,
                           method_generics: &ast::Generics) {
     debug!("encode_info_for_method: %d %s %u %u", m.id,
-           *ecx.tcx.sess.str_of(m.ident),
+           ecx.tcx.sess.str_of(m.ident),
            owner_generics.ty_params.len(),
            method_generics.ty_params.len());
     ebml_w.start_tag(tag_items_data_item);
@@ -1058,7 +1058,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
                         tcx.sess.span_unimpl(
                             item.span,
                             fmt!("Method %s is both provided and static",
-                                 *token::ident_to_str(&method_ty.ident)));
+                                 token::ident_to_str(&method_ty.ident)));
                     }
                     encode_type_param_bounds(ebml_w, ecx,
                                              &m.generics.ty_params);
@@ -1278,11 +1278,11 @@ fn synthesize_crate_attrs(ecx: @EncodeContext,
         assert!(!ecx.link_meta.vers.is_empty());
 
         let name_item =
-            attr::mk_name_value_item_str(@~"name",
-                                         @ecx.link_meta.name.to_owned());
+            attr::mk_name_value_item_str(@"name",
+                                         ecx.link_meta.name);
         let vers_item =
-            attr::mk_name_value_item_str(@~"vers",
-                                         @ecx.link_meta.vers.to_owned());
+            attr::mk_name_value_item_str(@"vers",
+                                         ecx.link_meta.vers);
 
         let other_items =
             {
@@ -1291,7 +1291,7 @@ fn synthesize_crate_attrs(ecx: @EncodeContext,
             };
 
         let meta_items = vec::append(~[name_item, vers_item], other_items);
-        let link_item = attr::mk_list_item(@~"link", meta_items);
+        let link_item = attr::mk_list_item(@"link", meta_items);
 
         return attr::mk_attr(link_item);
     }
@@ -1300,15 +1300,15 @@ fn synthesize_crate_attrs(ecx: @EncodeContext,
     let mut found_link_attr = false;
     for crate.node.attrs.each |attr| {
         attrs.push(
-            if *attr::get_attr_name(attr) != ~"link" {
-                /*bad*/copy *attr
+            if "link" != attr::get_attr_name(attr)  {
+                copy *attr
             } else {
                 match attr.node.value.node {
                   meta_list(_, ref l) => {
                     found_link_attr = true;;
                     synthesize_link_attr(ecx, /*bad*/copy *l)
                   }
-                  _ => /*bad*/copy *attr
+                  _ => copy *attr
                 }
             });
     }
@@ -1329,7 +1329,7 @@ fn encode_crate_deps(ecx: @EncodeContext,
         let mut deps = ~[];
         do cstore::iter_crate_data(cstore) |key, val| {
             let dep = decoder::crate_dep {cnum: key,
-                       name: ecx.tcx.sess.ident_of(/*bad*/ copy *val.name),
+                       name: ecx.tcx.sess.ident_of(val.name),
                        vers: decoder::get_crate_vers(val.data),
                        hash: decoder::get_crate_hash(val.data)};
             deps.push(dep);
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 370804cb750..dab18e74209 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -48,7 +48,7 @@ pub struct Context {
     span: span,
     ident: ast::ident,
     metas: ~[@ast::meta_item],
-    hash: @~str,
+    hash: @str,
     os: os,
     is_static: bool,
     intr: @ident_interner
@@ -60,7 +60,7 @@ pub fn load_library_crate(cx: &Context) -> (~str, @~[u8]) {
       None => {
         cx.diag.span_fatal(
             cx.span, fmt!("can't find crate for `%s`",
-                          *token::ident_to_str(&cx.ident)));
+                          token::ident_to_str(&cx.ident)));
       }
     }
 }
@@ -89,7 +89,7 @@ fn find_library_crate_aux(
     filesearch: @filesearch::FileSearch
 ) -> Option<(~str, @~[u8])> {
     let crate_name = crate_name_from_metas(cx.metas);
-    let prefix: ~str = prefix + *crate_name + "-";
+    let prefix: ~str = prefix + crate_name + "-";
     let suffix: ~str = /*bad*/copy suffix;
 
     let mut matches = ~[];
@@ -128,7 +128,7 @@ fn find_library_crate_aux(
         Some(/*bad*/copy matches[0])
     } else {
         cx.diag.span_err(
-            cx.span, fmt!("multiple matching crates for `%s`", *crate_name));
+            cx.span, fmt!("multiple matching crates for `%s`", crate_name));
         cx.diag.handler().note("candidates:");
         for matches.each |&(ident, data)| {
             cx.diag.handler().note(fmt!("path: %s", ident));
@@ -140,7 +140,7 @@ fn find_library_crate_aux(
     }
 }
 
-pub fn crate_name_from_metas(metas: &[@ast::meta_item]) -> @~str {
+pub fn crate_name_from_metas(metas: &[@ast::meta_item]) -> @str {
     let name_items = attr::find_meta_items_by_name(metas, "name");
     match name_items.last_opt() {
         Some(i) => {
@@ -166,7 +166,7 @@ pub fn note_linkage_attrs(intr: @ident_interner,
 
 fn crate_matches(crate_data: @~[u8],
                  metas: &[@ast::meta_item],
-                 hash: @~str) -> bool {
+                 hash: @str) -> bool {
     let attrs = decoder::get_crate_attributes(crate_data);
     let linkage_metas = attr::find_linkage_metas(attrs);
     if !hash.is_empty() {
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
index 947c6863414..d9377afa9a5 100644
--- a/src/librustc/metadata/tyencode.rs
+++ b/src/librustc/metadata/tyencode.rs
@@ -41,7 +41,7 @@ pub struct ctxt {
 pub struct ty_abbrev {
     pos: uint,
     len: uint,
-    s: @~str
+    s: @str
 }
 
 pub enum abbrev_ctxt {
@@ -60,12 +60,12 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
     match cx.abbrevs {
       ac_no_abbrevs => {
         let result_str = match cx.tcx.short_names_cache.find(&t) {
-            Some(&s) => /*bad*/copy *s,
+            Some(&s) => s,
             None => {
                 let s = do io::with_str_writer |wr| {
                     enc_sty(wr, cx, /*bad*/copy ty::get(t).sty);
-                };
-                cx.tcx.short_names_cache.insert(t, @copy s);
+                }.to_managed();
+                cx.tcx.short_names_cache.insert(t, s);
                 s
           }
         };
@@ -73,7 +73,7 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
       }
       ac_use_abbrevs(abbrevs) => {
           match abbrevs.find(&t) {
-              Some(a) => { w.write_str(*a.s); return; }
+              Some(a) => { w.write_str(a.s); return; }
               None => {}
           }
           let pos = w.tell();
@@ -89,8 +89,8 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
           let abbrev_len = 3u + estimate_sz(pos) + estimate_sz(len);
           if abbrev_len < len {
               // I.e. it's actually an abbreviation.
-              let s = fmt!("#%x:%x#", pos, len);
-              let a = ty_abbrev { pos: pos, len: len, s: @s };
+              let s = fmt!("#%x:%x#", pos, len).to_managed();
+              let a = ty_abbrev { pos: pos, len: len, s: s };
               abbrevs.insert(t, a);
           }
           return;
@@ -171,7 +171,7 @@ fn enc_bound_region(w: @io::Writer, cx: @ctxt, br: ty::bound_region) {
       }
       ty::br_named(s) => {
         w.write_char('[');
-        w.write_str(*cx.tcx.sess.str_of(s));
+        w.write_str(cx.tcx.sess.str_of(s));
         w.write_char(']')
       }
       ty::br_cap_avoid(id, br) => {
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 0c68251acbe..209ab4ce3d4 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -88,7 +88,7 @@ pub fn encode_inlined_item(ecx: @e::EncodeContext,
                            maps: Maps) {
     debug!("> Encoding inlined item: %s::%s (%u)",
            ast_map::path_to_str(path, token::get_ident_interner()),
-           *ecx.tcx.sess.str_of(ii.ident()),
+           ecx.tcx.sess.str_of(ii.ident()),
            ebml_w.writer.tell());
 
     let id_range = ast_util::compute_id_range_for_inlined_item(&ii);
@@ -101,7 +101,7 @@ pub fn encode_inlined_item(ecx: @e::EncodeContext,
 
     debug!("< Encoded inlined fn: %s::%s (%u)",
            ast_map::path_to_str(path, token::get_ident_interner()),
-           *ecx.tcx.sess.str_of(ii.ident()),
+           ecx.tcx.sess.str_of(ii.ident()),
            ebml_w.writer.tell());
 }
 
@@ -131,10 +131,10 @@ pub fn decode_inlined_item(cdata: @cstore::crate_metadata,
         };
         let raw_ii = decode_ast(ast_doc);
         let ii = renumber_ast(xcx, raw_ii);
-        debug!("Fn named: %s", *tcx.sess.str_of(ii.ident()));
+        debug!("Fn named: %s", tcx.sess.str_of(ii.ident()));
         debug!("< Decoded inlined fn: %s::%s",
                ast_map::path_to_str(path, token::get_ident_interner()),
-               *tcx.sess.str_of(ii.ident()));
+               tcx.sess.str_of(ii.ident()));
         ast_map::map_decoded_item(tcx.sess.diagnostic(),
                                   dcx.tcx.items, path, &ii);
         decode_side_tables(xcx, ast_doc);
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 982751ee5a5..95e26e9e42f 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -711,7 +711,7 @@ impl BorrowckCtxt {
             LpVar(id) => {
                 match self.tcx.items.find(&id) {
                     Some(&ast_map::node_local(ref ident)) => {
-                        out.push_str(*token::ident_to_str(ident));
+                        out.push_str(token::ident_to_str(ident));
                     }
                     r => {
                         self.tcx.sess.bug(
@@ -726,7 +726,7 @@ impl BorrowckCtxt {
                 match fname {
                     mc::NamedField(ref fname) => {
                         out.push_char('.');
-                        out.push_str(*token::ident_to_str(fname));
+                        out.push_str(token::ident_to_str(fname));
                     }
                     mc::PositionalField(idx) => {
                         out.push_char('#'); // invent a notation here
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index d32882a2f49..116282b2627 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -144,8 +144,8 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
             match ty::get(ty).sty {
                 ty::ty_bool => {
                     match (*ctor) {
-                        val(const_bool(true)) => Some(@~"true"),
-                        val(const_bool(false)) => Some(@~"false"),
+                        val(const_bool(true)) => Some(@"true"),
+                        val(const_bool(false)) => Some(@"false"),
                         _ => None
                     }
                 }
@@ -165,7 +165,7 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
                 }
                 ty::ty_unboxed_vec(*) | ty::ty_evec(*) => {
                     match *ctor {
-                        vec(n) => Some(@fmt!("vectors of length %u", n)),
+                        vec(n) => Some(fmt!("vectors of length %u", n).to_managed()),
                         _ => None
                     }
                 }
@@ -174,7 +174,7 @@ pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
         }
     };
     let msg = ~"non-exhaustive patterns" + match ext {
-        Some(ref s) => ~": " + **s + " not covered",
+        Some(ref s) => fmt!(": %s not covered",  *s),
         None => ~""
     };
     cx.tcx.sess.span_err(sp, msg);
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index a24faf91021..14fcbcc1f14 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -236,14 +236,14 @@ pub enum const_val {
     const_float(f64),
     const_int(i64),
     const_uint(u64),
-    const_str(~str),
+    const_str(@str),
     const_bool(bool)
 }
 
 pub fn eval_const_expr(tcx: middle::ty::ctxt, e: @expr) -> const_val {
     match eval_const_expr_partial(tcx, e) {
-        Ok(ref r) => (/*bad*/copy *r),
-        Err(ref s) => tcx.sess.span_fatal(e.span, *s)
+        Ok(r) => r,
+        Err(s) => tcx.sess.span_fatal(e.span, s)
     }
 }
 
@@ -409,13 +409,13 @@ pub fn eval_const_expr_partial(tcx: middle::ty::ctxt, e: @expr)
 
 pub fn lit_to_const(lit: @lit) -> const_val {
     match lit.node {
-      lit_str(s) => const_str(/*bad*/copy *s),
+      lit_str(s) => const_str(s),
       lit_int(n, _) => const_int(n),
       lit_uint(n, _) => const_uint(n),
       lit_int_unsuffixed(n) => const_int(n),
-      lit_float(n, _) => const_float(float::from_str(*n).get() as f64),
+      lit_float(n, _) => const_float(float::from_str(n).get() as f64),
       lit_float_unsuffixed(n) =>
-        const_float(float::from_str(*n).get() as f64),
+        const_float(float::from_str(n).get() as f64),
       lit_nil => const_int(0i64),
       lit_bool(b) => const_bool(b)
     }
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index dc5f86ea0de..eaf05a4a85f 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -269,50 +269,50 @@ fn LanguageItemCollector(crate: @crate,
                       -> LanguageItemCollector {
     let mut item_refs = HashMap::new();
 
-    item_refs.insert(@~"const", ConstTraitLangItem as uint);
-    item_refs.insert(@~"copy", CopyTraitLangItem as uint);
-    item_refs.insert(@~"owned", OwnedTraitLangItem as uint);
-    item_refs.insert(@~"sized", SizedTraitLangItem as uint);
+    item_refs.insert(@"const", ConstTraitLangItem as uint);
+    item_refs.insert(@"copy", CopyTraitLangItem as uint);
+    item_refs.insert(@"owned", OwnedTraitLangItem as uint);
+    item_refs.insert(@"sized", SizedTraitLangItem as uint);
 
-    item_refs.insert(@~"drop", DropTraitLangItem as uint);
+    item_refs.insert(@"drop", DropTraitLangItem as uint);
 
-    item_refs.insert(@~"add", AddTraitLangItem as uint);
-    item_refs.insert(@~"sub", SubTraitLangItem as uint);
-    item_refs.insert(@~"mul", MulTraitLangItem as uint);
-    item_refs.insert(@~"div", DivTraitLangItem as uint);
-    item_refs.insert(@~"rem", RemTraitLangItem as uint);
-    item_refs.insert(@~"neg", NegTraitLangItem as uint);
-    item_refs.insert(@~"not", NotTraitLangItem as uint);
-    item_refs.insert(@~"bitxor", BitXorTraitLangItem as uint);
-    item_refs.insert(@~"bitand", BitAndTraitLangItem as uint);
-    item_refs.insert(@~"bitor", BitOrTraitLangItem as uint);
-    item_refs.insert(@~"shl", ShlTraitLangItem as uint);
-    item_refs.insert(@~"shr", ShrTraitLangItem as uint);
-    item_refs.insert(@~"index", IndexTraitLangItem as uint);
+    item_refs.insert(@"add", AddTraitLangItem as uint);
+    item_refs.insert(@"sub", SubTraitLangItem as uint);
+    item_refs.insert(@"mul", MulTraitLangItem as uint);
+    item_refs.insert(@"div", DivTraitLangItem as uint);
+    item_refs.insert(@"rem", RemTraitLangItem as uint);
+    item_refs.insert(@"neg", NegTraitLangItem as uint);
+    item_refs.insert(@"not", NotTraitLangItem as uint);
+    item_refs.insert(@"bitxor", BitXorTraitLangItem as uint);
+    item_refs.insert(@"bitand", BitAndTraitLangItem as uint);
+    item_refs.insert(@"bitor", BitOrTraitLangItem as uint);
+    item_refs.insert(@"shl", ShlTraitLangItem as uint);
+    item_refs.insert(@"shr", ShrTraitLangItem as uint);
+    item_refs.insert(@"index", IndexTraitLangItem as uint);
 
-    item_refs.insert(@~"eq", EqTraitLangItem as uint);
-    item_refs.insert(@~"ord", OrdTraitLangItem as uint);
+    item_refs.insert(@"eq", EqTraitLangItem as uint);
+    item_refs.insert(@"ord", OrdTraitLangItem as uint);
 
-    item_refs.insert(@~"str_eq", StrEqFnLangItem as uint);
-    item_refs.insert(@~"uniq_str_eq", UniqStrEqFnLangItem as uint);
-    item_refs.insert(@~"annihilate", AnnihilateFnLangItem as uint);
-    item_refs.insert(@~"log_type", LogTypeFnLangItem as uint);
-    item_refs.insert(@~"fail_", FailFnLangItem as uint);
-    item_refs.insert(@~"fail_bounds_check",
+    item_refs.insert(@"str_eq", StrEqFnLangItem as uint);
+    item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint);
+    item_refs.insert(@"annihilate", AnnihilateFnLangItem as uint);
+    item_refs.insert(@"log_type", LogTypeFnLangItem as uint);
+    item_refs.insert(@"fail_", FailFnLangItem as uint);
+    item_refs.insert(@"fail_bounds_check",
                      FailBoundsCheckFnLangItem as uint);
-    item_refs.insert(@~"exchange_malloc", ExchangeMallocFnLangItem as uint);
-    item_refs.insert(@~"exchange_free", ExchangeFreeFnLangItem as uint);
-    item_refs.insert(@~"malloc", MallocFnLangItem as uint);
-    item_refs.insert(@~"free", FreeFnLangItem as uint);
-    item_refs.insert(@~"borrow_as_imm", BorrowAsImmFnLangItem as uint);
-    item_refs.insert(@~"borrow_as_mut", BorrowAsMutFnLangItem as uint);
-    item_refs.insert(@~"return_to_mut", ReturnToMutFnLangItem as uint);
-    item_refs.insert(@~"check_not_borrowed",
+    item_refs.insert(@"exchange_malloc", ExchangeMallocFnLangItem as uint);
+    item_refs.insert(@"exchange_free", ExchangeFreeFnLangItem as uint);
+    item_refs.insert(@"malloc", MallocFnLangItem as uint);
+    item_refs.insert(@"free", FreeFnLangItem as uint);
+    item_refs.insert(@"borrow_as_imm", BorrowAsImmFnLangItem as uint);
+    item_refs.insert(@"borrow_as_mut", BorrowAsMutFnLangItem as uint);
+    item_refs.insert(@"return_to_mut", ReturnToMutFnLangItem as uint);
+    item_refs.insert(@"check_not_borrowed",
                      CheckNotBorrowedFnLangItem as uint);
-    item_refs.insert(@~"strdup_uniq", StrDupUniqFnLangItem as uint);
-    item_refs.insert(@~"record_borrow", RecordBorrowFnLangItem as uint);
-    item_refs.insert(@~"unrecord_borrow", UnrecordBorrowFnLangItem as uint);
-    item_refs.insert(@~"start", StartFnLangItem as uint);
+    item_refs.insert(@"strdup_uniq", StrDupUniqFnLangItem as uint);
+    item_refs.insert(@"record_borrow", RecordBorrowFnLangItem as uint);
+    item_refs.insert(@"unrecord_borrow", UnrecordBorrowFnLangItem as uint);
+    item_refs.insert(@"start", StartFnLangItem as uint);
 
     LanguageItemCollector {
         crate: crate,
@@ -328,7 +328,7 @@ struct LanguageItemCollector {
     crate: @crate,
     session: Session,
 
-    item_refs: HashMap<@~str, uint>,
+    item_refs: HashMap<@str, uint>,
 }
 
 impl LanguageItemCollector {
@@ -366,9 +366,9 @@ impl LanguageItemCollector {
 
     pub fn match_and_collect_item(&mut self,
                                   item_def_id: def_id,
-                                  key: @~str,
-                                  value: @~str) {
-        if *key != ~"lang" {
+                                  key: @str,
+                                  value: @str) {
+        if "lang" != key {
             return;    // Didn't match.
         }
 
@@ -419,7 +419,7 @@ impl LanguageItemCollector {
         for self.item_refs.each |&key, &item_ref| {
             match self.items.items[item_ref] {
                 None => {
-                    self.session.err(fmt!("no item found for `%s`", *key));
+                    self.session.err(fmt!("no item found for `%s`", key));
                 }
                 Some(_) => {
                     // OK.
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index bb6a6231288..8f504266f97 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -119,7 +119,7 @@ struct LintSpec {
     default: level
 }
 
-pub type LintDict = HashMap<~str, LintSpec>;
+pub type LintDict = HashMap<&'static str, LintSpec>;
 
 enum AttributedNode<'self> {
     Item(@ast::item),
@@ -290,7 +290,7 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
 pub fn get_lint_dict() -> LintDict {
     let mut map = HashMap::new();
     for lint_table.each|&(k, v)| {
-        map.insert(k.to_str(), v);
+        map.insert(k, v);
     }
     return map;
 }
@@ -352,10 +352,10 @@ impl Context {
         }
     }
 
-    fn lint_to_str(&self, lint: lint) -> ~str {
+    fn lint_to_str(&self, lint: lint) -> &'static str {
         for self.dict.each |k, v| {
             if v.lint == lint {
-                return copy *k;
+                return *k;
             }
         }
         fail!("unregistered lint %?", lint);
@@ -405,13 +405,13 @@ impl Context {
         // specified closure
         let mut pushed = 0u;
         for each_lint(self.tcx.sess, attrs) |meta, level, lintname| {
-            let lint = match self.dict.find(lintname) {
+            let lint = match self.dict.find_equiv(&lintname) {
               None => {
                 self.span_lint(
                     unrecognized_lint,
                     meta.span,
                     fmt!("unknown `%s` attribute: `%s`",
-                         level_to_str(level), *lintname));
+                         level_to_str(level), lintname));
                 loop
               }
               Some(lint) => { lint.lint }
@@ -422,7 +422,7 @@ impl Context {
                 self.tcx.sess.span_err(meta.span,
                     fmt!("%s(%s) overruled by outer forbid(%s)",
                          level_to_str(level),
-                         *lintname, *lintname));
+                         lintname, lintname));
                 loop;
             }
 
@@ -498,7 +498,7 @@ impl Context {
 
 pub fn each_lint(sess: session::Session,
                  attrs: &[ast::attribute],
-                 f: &fn(@ast::meta_item, level, &~str) -> bool) -> bool
+                 f: &fn(@ast::meta_item, level, @str) -> bool) -> bool
 {
     for [allow, warn, deny, forbid].each |&level| {
         let level_name = level_to_str(level);
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index b79eee9e7ca..47b55d85329 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -310,12 +310,12 @@ impl IrMaps {
         }
     }
 
-    pub fn variable_name(&mut self, var: Variable) -> @~str {
+    pub fn variable_name(&mut self, var: Variable) -> @str {
         match self.var_kinds[*var] {
             Local(LocalInfo { ident: nm, _ }) | Arg(_, nm) => {
                 self.tcx.sess.str_of(nm)
             },
-            ImplicitRet => @~"<implicit-ret>"
+            ImplicitRet => @"<implicit-ret>"
         }
     }
 
@@ -1578,12 +1578,12 @@ impl Liveness {
           FreeVarNode(span) => {
             self.tcx.sess.span_err(
                 span,
-                fmt!("capture of %s: `%s`", msg, *name));
+                fmt!("capture of %s: `%s`", msg, name));
           }
           ExprNode(span) => {
             self.tcx.sess.span_err(
                 span,
-                fmt!("use of %s: `%s`", msg, *name));
+                fmt!("use of %s: `%s`", msg, name));
           }
           ExitNode | VarDefNode(_) => {
             self.tcx.sess.span_bug(
@@ -1593,7 +1593,7 @@ impl Liveness {
         }
     }
 
-    pub fn should_warn(&self, var: Variable) -> Option<@~str> {
+    pub fn should_warn(&self, var: Variable) -> Option<@str> {
         let name = self.ir.variable_name(var);
         if name[0] == ('_' as u8) { None } else { Some(name) }
     }
@@ -1638,10 +1638,10 @@ impl Liveness {
                 if is_assigned {
                     self.tcx.sess.add_lint(unused_variable, id, sp,
                         fmt!("variable `%s` is assigned to, \
-                                  but never used", **name));
+                                  but never used", *name));
                 } else {
                     self.tcx.sess.add_lint(unused_variable, id, sp,
-                        fmt!("unused variable: `%s`", **name));
+                        fmt!("unused variable: `%s`", *name));
                 }
             }
             true
@@ -1659,7 +1659,7 @@ impl Liveness {
             let r = self.should_warn(var);
             for r.iter().advance |name| {
                 self.tcx.sess.add_lint(dead_assignment, id, sp,
-                    fmt!("value assigned to `%s` is never read", **name));
+                    fmt!("value assigned to `%s` is never read", *name));
             }
         }
     }
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 2802a92a1f9..3152b66440c 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -1201,7 +1201,7 @@ pub fn ptr_sigil(ptr: ptr_kind) -> ~str {
 impl Repr for InteriorKind {
     fn repr(&self, tcx: ty::ctxt) -> ~str {
         match *self {
-            InteriorField(NamedField(fld)) => copy *tcx.sess.str_of(fld),
+            InteriorField(NamedField(fld)) => tcx.sess.str_of(fld).to_owned(),
             InteriorField(PositionalField(i)) => fmt!("#%?", i),
             InteriorElement(_) => ~"[]",
         }
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 11f9cc2bed1..60193f3fe5d 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -235,7 +235,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
             if field.ident != ident { loop; }
             if field.vis == private {
                 tcx.sess.span_err(span, fmt!("field `%s` is private",
-                                             *token::ident_to_str(&ident)));
+                                             token::ident_to_str(&ident)));
             }
             break;
         }
@@ -255,7 +255,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                      !privileged_items.contains(&(container_id.node))) {
                 tcx.sess.span_err(span,
                                   fmt!("method `%s` is private",
-                                       *token::ident_to_str(name)));
+                                       token::ident_to_str(name)));
             }
         } else {
             let visibility =
@@ -263,7 +263,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
             if visibility != public {
                 tcx.sess.span_err(span,
                                   fmt!("method `%s` is private",
-                                       *token::ident_to_str(name)));
+                                       token::ident_to_str(name)));
             }
         }
     };
@@ -283,13 +283,13 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                             !privileged_items.contains(&def_id.node) {
                         tcx.sess.span_err(span,
                                           fmt!("function `%s` is private",
-                                               *token::ident_to_str(path.idents.last())));
+                                               token::ident_to_str(path.idents.last())));
                     }
                 } else if csearch::get_item_visibility(tcx.sess.cstore,
                                                        def_id) != public {
                     tcx.sess.span_err(span,
                                       fmt!("function `%s` is private",
-                                           *token::ident_to_str(path.idents.last())));
+                                           token::ident_to_str(path.idents.last())));
                 }
             }
             _ => {}
@@ -328,7 +328,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                                              .contains(&(trait_id.node)) => {
                                             tcx.sess.span_err(span,
                                                               fmt!("method `%s` is private",
-                                                                   *token::ident_to_str(&method
+                                                                   token::ident_to_str(&method
                                                                                         .ident)));
                                         }
                                         provided(_) | required(_) => {
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 73ac82ea549..b3baa16a884 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -84,7 +84,7 @@ pub type TraitMap = HashMap<node_id,@mut ~[def_id]>;
 pub type ExportMap2 = @mut HashMap<node_id, ~[Export2]>;
 
 pub struct Export2 {
-    name: @~str,        // The name of the target.
+    name: @str,        // The name of the target.
     def_id: def_id,     // The definition of the target.
     reexport: bool,     // Whether this is a reexport.
 }
@@ -1035,14 +1035,14 @@ impl Resolver {
                     self.session.span_err(sp,
                         fmt!("duplicate definition of %s `%s`",
                              namespace_to_str(ns),
-                             *self.session.str_of(name)));
+                             self.session.str_of(name)));
                     {
                         let r = child.span_for_namespace(ns);
                         for r.iter().advance |sp| {
                             self.session.span_note(*sp,
                                  fmt!("first definition of %s %s here:",
                                       namespace_to_str(ns),
-                                      *self.session.str_of(name)));
+                                      self.session.str_of(name)));
                         }
                     }
                 }
@@ -1695,7 +1695,7 @@ impl Resolver {
                   debug!("(building reduced graph for \
                           external crate) ... adding \
                           trait method '%s'",
-                         *self.session.str_of(method_name));
+                         self.session.str_of(method_name));
 
                   // Add it to the trait info if not static.
                   if explicit_self != sty_static {
@@ -1824,7 +1824,7 @@ impl Resolver {
                                              visibility,
                                              &mut modules,
                                              child_name_bindings,
-                                             *self.session.str_of(
+                                             self.session.str_of(
                                                  final_ident),
                                              final_ident,
                                              new_parent);
@@ -1843,7 +1843,7 @@ impl Resolver {
                                     debug!("(building reduced graph for \
                                             external crate) processing \
                                             static methods for type name %s",
-                                            *self.session.str_of(
+                                            self.session.str_of(
                                                 final_ident));
 
                                     let (child_name_bindings, new_parent) =
@@ -1894,7 +1894,7 @@ impl Resolver {
                                         debug!("(building reduced graph for \
                                                  external crate) creating \
                                                  static method '%s'",
-                                               *self.session.str_of(ident));
+                                               self.session.str_of(ident));
 
                                         let (method_name_bindings, _) =
                                             self.add_child(
@@ -1945,7 +1945,7 @@ impl Resolver {
                         directive: privacy %? %s::%s",
                        privacy,
                        self.idents_to_str(directive.module_path),
-                       *self.session.str_of(target));
+                       self.session.str_of(target));
 
                 match module_.import_resolutions.find(&target) {
                     Some(&resolution) => {
@@ -2054,7 +2054,7 @@ impl Resolver {
                 Failed => {
                     // We presumably emitted an error. Continue.
                     let msg = fmt!("failed to resolve import `%s`",
-                                   *self.import_path_to_str(
+                                   self.import_path_to_str(
                                        import_directive.module_path,
                                        *import_directive.subclass));
                     self.session.span_err(import_directive.span, msg);
@@ -2077,30 +2077,30 @@ impl Resolver {
         let mut result = ~"";
         for idents.each |ident| {
             if first { first = false; } else { result += "::" };
-            result += *self.session.str_of(*ident);
+            result += self.session.str_of(*ident);
         };
         return result;
     }
 
     pub fn import_directive_subclass_to_str(@mut self,
                                             subclass: ImportDirectiveSubclass)
-                                            -> @~str {
+                                            -> @str {
         match subclass {
             SingleImport(_target, source) => self.session.str_of(source),
-            GlobImport => @~"*"
+            GlobImport => @"*"
         }
     }
 
     pub fn import_path_to_str(@mut self,
                               idents: &[ident],
                               subclass: ImportDirectiveSubclass)
-                              -> @~str {
+                              -> @str {
         if idents.is_empty() {
             self.import_directive_subclass_to_str(subclass)
         } else {
-            @fmt!("%s::%s",
-                 self.idents_to_str(idents),
-                 *self.import_directive_subclass_to_str(subclass))
+            (fmt!("%s::%s",
+                  self.idents_to_str(idents),
+                  self.import_directive_subclass_to_str(subclass))).to_managed()
         }
     }
 
@@ -2221,9 +2221,9 @@ impl Resolver {
                                  -> ResolveResult<()> {
         debug!("(resolving single import) resolving `%s` = `%s::%s` from \
                 `%s`",
-               *self.session.str_of(target),
+               self.session.str_of(target),
                self.module_to_str(containing_module),
-               *self.session.str_of(source),
+               self.session.str_of(source),
                self.module_to_str(module_));
 
         // We need to resolve both namespaces for this to succeed.
@@ -2427,12 +2427,12 @@ impl Resolver {
         let span = directive.span;
         if resolve_fail {
             self.session.span_err(span, fmt!("unresolved import: there is no `%s` in `%s`",
-                                             *self.session.str_of(source),
+                                             self.session.str_of(source),
                                              self.module_to_str(containing_module)));
             return Failed;
         } else if priv_fail {
             self.session.span_err(span, fmt!("unresolved import: found `%s` in `%s` but it is \
-                                             private", *self.session.str_of(source),
+                                             private", self.session.str_of(source),
                                              self.module_to_str(containing_module)));
             return Failed;
         }
@@ -2535,7 +2535,7 @@ impl Resolver {
 
             debug!("(resolving glob import) writing resolution `%s` in `%s` \
                     to `%s`, privacy=%?",
-                   *self.session.str_of(ident),
+                   self.session.str_of(ident),
                    self.module_to_str(containing_module),
                    self.module_to_str(module_),
                    copy dest_import_resolution.privacy);
@@ -2604,17 +2604,17 @@ impl Resolver {
                                               fmt!("unresolved import. maybe \
                                                     a missing `extern mod \
                                                     %s`?",
-                                                    *segment_name));
+                                                    segment_name));
                         return Failed;
                     }
                     self.session.span_err(span, fmt!("unresolved import: could not find `%s` in \
-                                                     `%s`.", *segment_name, module_name));
+                                                     `%s`.", segment_name, module_name));
                     return Failed;
                 }
                 Indeterminate => {
                     debug!("(resolving module path for import) module \
                             resolution is indeterminate: %s",
-                            *self.session.str_of(name));
+                            self.session.str_of(name));
                     return Indeterminate;
                 }
                 Success(target) => {
@@ -2628,7 +2628,7 @@ impl Resolver {
                                     self.session.span_err(span,
                                                           fmt!("not a \
                                                                 module `%s`",
-                                                               *self.session.
+                                                               self.session.
                                                                    str_of(
                                                                     name)));
                                     return Failed;
@@ -2656,7 +2656,7 @@ impl Resolver {
                             // There are no type bindings at all.
                             self.session.span_err(span,
                                                   fmt!("not a module `%s`",
-                                                       *self.session.str_of(
+                                                       self.session.str_of(
                                                             name)));
                             return Failed;
                         }
@@ -2783,7 +2783,7 @@ impl Resolver {
                                          -> ResolveResult<Target> {
         debug!("(resolving item in lexical scope) resolving `%s` in \
                 namespace %? in `%s`",
-               *self.session.str_of(name),
+               self.session.str_of(name),
                namespace,
                self.module_to_str(module_));
 
@@ -2997,11 +2997,11 @@ impl Resolver {
         // top of the crate otherwise.
         let mut containing_module;
         let mut i;
-        if *token::ident_to_str(&module_path[0]) == ~"self" {
+        if "self" == token::ident_to_str(&module_path[0]) {
             containing_module =
                 self.get_nearest_normal_module_parent_or_self(module_);
             i = 1;
-        } else if *token::ident_to_str(&module_path[0]) == ~"super" {
+        } else if "super" == token::ident_to_str(&module_path[0]) {
             containing_module =
                 self.get_nearest_normal_module_parent_or_self(module_);
             i = 0;  // We'll handle `super` below.
@@ -3011,7 +3011,7 @@ impl Resolver {
 
         // Now loop through all the `super`s we find.
         while i < module_path.len() &&
-                *token::ident_to_str(&module_path[i]) == ~"super" {
+                "super" == token::ident_to_str(&module_path[i]) {
             debug!("(resolving module prefix) resolving `super` at %s",
                    self.module_to_str(containing_module));
             match self.get_nearest_normal_module_parent(containing_module) {
@@ -3039,7 +3039,7 @@ impl Resolver {
                                   name_search_type: NameSearchType)
                                   -> ResolveResult<Target> {
         debug!("(resolving name in module) resolving `%s` in `%s`",
-               *self.session.str_of(name),
+               self.session.str_of(name),
                self.module_to_str(module_));
 
         // First, check the direct children of the module.
@@ -3112,7 +3112,7 @@ impl Resolver {
 
         // We're out of luck.
         debug!("(resolving name in module) failed to resolve `%s`",
-               *self.session.str_of(name));
+               self.session.str_of(name));
         return Failed;
     }
 
@@ -3230,7 +3230,7 @@ impl Resolver {
             (Some(d), Some(Public)) => {
                 debug!("(computing exports) YES: %s '%s' => %?",
                        if reexport { ~"reexport" } else { ~"export"},
-                       *self.session.str_of(ident),
+                       self.session.str_of(ident),
                        def_id_of_def(d));
                 exports2.push(Export2 {
                     reexport: reexport,
@@ -3252,7 +3252,7 @@ impl Resolver {
                                   module_: @mut Module) {
         for module_.children.each |ident, namebindings| {
             debug!("(computing exports) maybe export '%s'",
-                   *self.session.str_of(*ident));
+                   self.session.str_of(*ident));
             self.add_exports_of_namebindings(&mut *exports2,
                                              *ident,
                                              *namebindings,
@@ -3268,14 +3268,14 @@ impl Resolver {
         for module_.import_resolutions.each |ident, importresolution| {
             if importresolution.privacy != Public {
                 debug!("(computing exports) not reexporting private `%s`",
-                       *self.session.str_of(*ident));
+                       self.session.str_of(*ident));
                 loop;
             }
             for [ TypeNS, ValueNS ].each |ns| {
                 match importresolution.target_for_namespace(*ns) {
                     Some(target) => {
                         debug!("(computing exports) maybe reexport '%s'",
-                               *self.session.str_of(*ident));
+                               self.session.str_of(*ident));
                         self.add_exports_of_namebindings(&mut *exports2,
                                                          *ident,
                                                          target.bindings,
@@ -3318,7 +3318,7 @@ impl Resolver {
                 match orig_module.children.find(&name) {
                     None => {
                         debug!("!!! (with scope) didn't find `%s` in `%s`",
-                               *self.session.str_of(name),
+                               self.session.str_of(name),
                                self.module_to_str(orig_module));
                     }
                     Some(name_bindings) => {
@@ -3326,7 +3326,7 @@ impl Resolver {
                             None => {
                                 debug!("!!! (with scope) didn't find module \
                                         for `%s` in `%s`",
-                                       *self.session.str_of(name),
+                                       self.session.str_of(name),
                                        self.module_to_str(orig_module));
                             }
                             Some(module_) => {
@@ -3503,7 +3503,7 @@ impl Resolver {
 
     pub fn resolve_item(@mut self, item: @item, visitor: ResolveVisitor) {
         debug!("(resolving item) resolving %s",
-               *self.session.str_of(item.ident));
+               self.session.str_of(item.ident));
 
         // Items with the !resolve_unexported attribute are X-ray contexts.
         // This is used to allow the test runner to run unexported tests.
@@ -4044,7 +4044,7 @@ impl Resolver {
                         p.span,
                         fmt!("variable `%s` from pattern #1 is \
                                   not bound in pattern #%u",
-                             *self.session.str_of(key), i + 1));
+                             self.session.str_of(key), i + 1));
                   }
                   Some(binding_i) => {
                     if binding_0.binding_mode != binding_i.binding_mode {
@@ -4052,7 +4052,7 @@ impl Resolver {
                             binding_i.span,
                             fmt!("variable `%s` is bound with different \
                                       mode in pattern #%u than in pattern #1",
-                                 *self.session.str_of(key), i + 1));
+                                 self.session.str_of(key), i + 1));
                     }
                   }
                 }
@@ -4064,7 +4064,7 @@ impl Resolver {
                         binding.span,
                         fmt!("variable `%s` from pattern #%u is \
                                   not bound in pattern #1",
-                             *self.session.str_of(key), i + 1));
+                             self.session.str_of(key), i + 1));
                 }
             }
         }
@@ -4148,7 +4148,7 @@ impl Resolver {
                             Some(def) => {
                                 debug!("(resolving type) resolved `%s` to \
                                         type %?",
-                                       *self.session.str_of(
+                                       self.session.str_of(
                                             *path.idents.last()),
                                        def);
                                 result_def = Some(def);
@@ -4224,7 +4224,7 @@ impl Resolver {
                                 if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `%s` to \
                                     struct or enum variant",
-                                    *self.session.str_of(ident));
+                                    self.session.str_of(ident));
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -4238,13 +4238,13 @@ impl Resolver {
                                                         shadows an enum \
                                                         variant or unit-like \
                                                         struct in scope",
-                                                        *self.session
+                                                        self.session
                                                             .str_of(ident)));
                         }
                         FoundConst(def) if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `%s` to \
                                     constant",
-                                    *self.session.str_of(ident));
+                                    self.session.str_of(ident));
 
                             self.enforce_default_binding_mode(
                                 pattern,
@@ -4259,7 +4259,7 @@ impl Resolver {
                         }
                         BareIdentifierPatternUnresolved => {
                             debug!("(resolving pattern) binding `%s`",
-                                   *self.session.str_of(ident));
+                                   self.session.str_of(ident));
 
                             let is_mutable = mutability == Mutable;
 
@@ -4350,7 +4350,7 @@ impl Resolver {
                             self.session.span_err(
                                 path.span,
                                 fmt!("`%s` is not an enum variant or constant",
-                                     *self.session.str_of(
+                                     self.session.str_of(
                                          *path.idents.last())));
                         }
                         None => {
@@ -4378,7 +4378,7 @@ impl Resolver {
                             self.session.span_err(
                                 path.span,
                                 fmt!("`%s` is not an enum variant, struct or const",
-                                     *self.session.str_of(
+                                     self.session.str_of(
                                          *path.idents.last())));
                         }
                         None => {
@@ -4753,7 +4753,7 @@ impl Resolver {
             Some(dl_def(def)) => {
                 debug!("(resolving path in local ribs) resolved `%s` to \
                         local: %?",
-                       *self.session.str_of(ident),
+                       self.session.str_of(ident),
                        def);
                 return Some(def);
             }
@@ -4811,7 +4811,7 @@ impl Resolver {
                     Some(def) => {
                         debug!("(resolving item path in lexical scope) \
                                 resolved `%s` to item",
-                               *self.session.str_of(ident));
+                               self.session.str_of(ident));
                         return Some(def);
                     }
                 }
@@ -4828,17 +4828,17 @@ impl Resolver {
     pub fn find_best_match_for_name(@mut self,
                                     name: &str,
                                     max_distance: uint)
-                                    -> Option<~str> {
+                                    -> Option<@str> {
         let this = &mut *self;
 
-        let mut maybes: ~[~str] = ~[];
+        let mut maybes: ~[@str] = ~[];
         let mut values: ~[uint] = ~[];
 
         let mut j = this.value_ribs.len();
         while j != 0 {
             j -= 1;
             for this.value_ribs[j].bindings.each_key |&k| {
-                vec::push(&mut maybes, copy *this.session.str_of(k));
+                vec::push(&mut maybes, this.session.str_of(k));
                 vec::push(&mut values, uint::max_value);
             }
         }
@@ -4857,7 +4857,7 @@ impl Resolver {
             values[smallest] != uint::max_value &&
             values[smallest] < name.len() + 2 &&
             values[smallest] <= max_distance &&
-            maybes[smallest] != name.to_owned() {
+            name != maybes[smallest] {
 
             Some(vec::swap_remove(&mut maybes, smallest))
 
@@ -4882,7 +4882,7 @@ impl Resolver {
                         match field.node.kind {
                           unnamed_field => {},
                           named_field(ident, _) => {
-                              if str::eq_slice(*this.session.str_of(ident),
+                              if str::eq_slice(this.session.str_of(ident),
                                                name) {
                                 return true
                               }
@@ -5007,7 +5007,7 @@ impl Resolver {
                         self.session.span_err(expr.span,
                                               fmt!("use of undeclared label \
                                                    `%s`",
-                                                   *self.session.str_of(
+                                                   self.session.str_of(
                                                        label))),
                     Some(dl_def(def @ def_label(_))) => {
                         self.record_def(expr.id, def)
@@ -5122,7 +5122,7 @@ impl Resolver {
     pub fn search_for_traits_containing_method(@mut self, name: ident)
                                                -> ~[def_id] {
         debug!("(searching for traits containing method) looking for '%s'",
-               *self.session.str_of(name));
+               self.session.str_of(name));
 
 
         let mut found_traits = ~[];
@@ -5227,7 +5227,7 @@ impl Resolver {
         debug!("(adding trait info) found trait %d:%d for method '%s'",
                trait_def_id.crate,
                trait_def_id.node,
-               *self.session.str_of(name));
+               self.session.str_of(name));
         found_traits.push(trait_def_id);
     }
 
@@ -5346,7 +5346,7 @@ impl Resolver {
 
         debug!("Children:");
         for module_.children.each_key |&name| {
-            debug!("* %s", *self.session.str_of(name));
+            debug!("* %s", self.session.str_of(name));
         }
 
         debug!("Import resolutions:");
@@ -5369,7 +5369,7 @@ impl Resolver {
                 }
             }
 
-            debug!("* %s:%s%s", *self.session.str_of(*name),
+            debug!("* %s:%s%s", self.session.str_of(*name),
                    value_repr, type_repr);
         }
     }
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index e3e431aae59..53d30e9c390 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -1699,7 +1699,7 @@ pub fn trans_match_inner(scope_cx: block,
             // Special case for empty types
             let fail_cx = @mut None;
             let f: mk_fail = || mk_fail(scope_cx, discr_expr.span,
-                            @~"scrutinizing value that can't exist", fail_cx);
+                            @"scrutinizing value that can't exist", fail_cx);
             Some(f)
         } else {
             None
@@ -1731,7 +1731,7 @@ pub fn trans_match_inner(scope_cx: block,
     bcx = controlflow::join_blocks(scope_cx, arm_cxs);
     return bcx;
 
-    fn mk_fail(bcx: block, sp: span, msg: @~str,
+    fn mk_fail(bcx: block, sp: span, msg: @str,
                finished: @mut Option<BasicBlockRef>) -> BasicBlockRef {
         match *finished { Some(bb) => return bb, _ => () }
         let fail_cx = sub_block(bcx, "case_fallthrough");
diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs
index 833146a935e..d73d57efbbf 100644
--- a/src/librustc/middle/trans/asm.rs
+++ b/src/librustc/middle/trans/asm.rs
@@ -33,7 +33,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
 
     // Prepare the output operands
     let outputs = do ia.outputs.map |&(c, out)| {
-        constraints.push(copy *c);
+        constraints.push(c);
 
         aoutputs.push(unpack_result!(bcx, {
             callee::trans_arg_expr(bcx,
@@ -69,7 +69,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
 
     // Now the input operands
     let inputs = do ia.inputs.map |&(c, in)| {
-        constraints.push(copy *c);
+        constraints.push(c);
 
         unpack_result!(bcx, {
             callee::trans_arg_expr(bcx,
@@ -90,14 +90,14 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
     let mut constraints = constraints.connect(",");
 
     let mut clobbers = getClobbers();
-    if *ia.clobbers != ~"" && clobbers != ~"" {
-        clobbers = *ia.clobbers + "," + clobbers;
+    if !ia.clobbers.is_empty() && !clobbers.is_empty() {
+        clobbers = fmt!("%s,%s", ia.clobbers, clobbers);
     } else {
-        clobbers += *ia.clobbers;
+        clobbers += ia.clobbers;
     };
 
     // Add the clobbers to our constraints list
-    if clobbers != ~"" && constraints != ~"" {
+    if !clobbers.is_empty() && !constraints.is_empty() {
         constraints += ",";
         constraints += clobbers;
     } else {
@@ -122,7 +122,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
         ast::asm_intel => lib::llvm::AD_Intel
     };
 
-    let r = do str::as_c_str(*ia.asm) |a| {
+    let r = do str::as_c_str(ia.asm) |a| {
         do str::as_c_str(constraints) |c| {
             InlineAsmCall(bcx, a, c, inputs, output, ia.volatile, ia.alignstack, dialect)
         }
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 855782f3a82..7337b07c402 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -485,9 +485,9 @@ pub fn set_glue_inlining(f: ValueRef, t: ty::t) {
 
 // Double-check that we never ask LLVM to declare the same symbol twice. It
 // silently mangles such symbols, breaking our linkage model.
-pub fn note_unique_llvm_symbol(ccx: @CrateContext, sym: @~str) {
+pub fn note_unique_llvm_symbol(ccx: @CrateContext, sym: @str) {
     if ccx.all_llvm_symbols.contains(&sym) {
-        ccx.sess.bug(~"duplicate LLVM symbol: " + *sym);
+        ccx.sess.bug(~"duplicate LLVM symbol: " + sym);
     }
     ccx.all_llvm_symbols.insert(sym);
 }
@@ -569,7 +569,7 @@ pub fn compare_scalar_types(cx: block,
             rslt(
                 controlflow::trans_fail(
                     cx, None,
-                    @~"attempt to compare values of type type"),
+                    @"attempt to compare values of type type"),
                 C_nil())
         }
         _ => {
@@ -791,9 +791,9 @@ pub fn cast_shift_rhs(op: ast::binop,
 pub fn fail_if_zero(cx: block, span: span, divrem: ast::binop,
                     rhs: ValueRef, rhs_t: ty::t) -> block {
     let text = if divrem == ast::div {
-        @~"attempted to divide by zero"
+        @"attempted to divide by zero"
     } else {
-        @~"attempted remainder with a divisor of zero"
+        @"attempted remainder with a divisor of zero"
     };
     let is_zero = match ty::get(rhs_t).sty {
       ty::ty_int(t) => {
@@ -1056,19 +1056,19 @@ pub fn load_if_immediate(cx: block, v: ValueRef, t: ty::t) -> ValueRef {
     return v;
 }
 
-pub fn trans_trace(bcx: block, sp_opt: Option<span>, trace_str: @~str) {
+pub fn trans_trace(bcx: block, sp_opt: Option<span>, trace_str: @str) {
     if !bcx.sess().trace() { return; }
     let _icx = bcx.insn_ctxt("trans_trace");
-    add_comment(bcx, *trace_str);
+    add_comment(bcx, trace_str);
     let V_trace_str = C_cstr(bcx.ccx(), trace_str);
     let (V_filename, V_line) = match sp_opt {
       Some(sp) => {
         let sess = bcx.sess();
         let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
-        (C_cstr(bcx.ccx(), @/*bad*/copy loc.file.name), loc.line as int)
+        (C_cstr(bcx.ccx(), loc.file.name), loc.line as int)
       }
       None => {
-        (C_cstr(bcx.ccx(), @~"<runtime>"), 0)
+        (C_cstr(bcx.ccx(), @"<runtime>"), 0)
       }
     };
     let ccx = bcx.ccx();
@@ -1187,7 +1187,7 @@ pub fn new_block(cx: fn_ctxt, parent: Option<block>, kind: block_kind,
         special_idents::invalid
     };
     unsafe {
-        let llbb = str::as_c_str(*cx.ccx.sess.str_of(s), |buf| {
+        let llbb = str::as_c_str(cx.ccx.sess.str_of(s), |buf| {
             llvm::LLVMAppendBasicBlockInContext(cx.ccx.llcx, cx.llfn, buf)
         });
         let bcx = mk_block(llbb,
@@ -1308,7 +1308,7 @@ pub fn cleanup_and_leave(bcx: block,
         if bcx.sess().trace() {
             trans_trace(
                 bcx, None,
-                @fmt!("cleanup_and_leave(%s)", cur.to_str()));
+                (fmt!("cleanup_and_leave(%s)", cur.to_str())).to_managed());
         }
 
         match cur.kind {
@@ -1427,7 +1427,7 @@ pub fn alloc_local(cx: block, local: @ast::local) -> block {
     let val = alloc_ty(cx, t);
     if cx.sess().opts.debuginfo {
         for simple_name.iter().advance |name| {
-            str::as_c_str(*cx.ccx().sess.str_of(*name), |buf| {
+            str::as_c_str(cx.ccx().sess.str_of(*name), |buf| {
                 unsafe {
                     llvm::LLVMSetValueName(val, buf)
                 }
@@ -1453,12 +1453,8 @@ pub fn call_memcpy(cx: block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, a
     let _icx = cx.insn_ctxt("call_memcpy");
     let ccx = cx.ccx();
     let key = match ccx.sess.targ_cfg.arch {
-        X86 | Arm | Mips => {
-            ~"llvm.memcpy.p0i8.p0i8.i32"
-        }
-        X86_64 => {
-            ~"llvm.memcpy.p0i8.p0i8.i64"
-        }
+        X86 | Arm | Mips => "llvm.memcpy.p0i8.p0i8.i32",
+        X86_64 => "llvm.memcpy.p0i8.p0i8.i64"
     };
     let memcpy = *ccx.intrinsics.get(&key);
     let src_ptr = PointerCast(cx, src, T_ptr(T_i8()));
@@ -1499,15 +1495,10 @@ pub fn memzero(cx: block, llptr: ValueRef, llty: TypeRef) {
     let _icx = cx.insn_ctxt("memzero");
     let ccx = cx.ccx();
 
-    let intrinsic_key;
-    match ccx.sess.targ_cfg.arch {
-        X86 | Arm | Mips => {
-            intrinsic_key = ~"llvm.memset.p0i8.i32";
-        }
-        X86_64 => {
-            intrinsic_key = ~"llvm.memset.p0i8.i64";
-        }
-    }
+    let intrinsic_key = match ccx.sess.targ_cfg.arch {
+        X86 | Arm | Mips => "llvm.memset.p0i8.i32",
+        X86_64 => "llvm.memset.p0i8.i64"
+    };
 
     let llintrinsicfn = *ccx.intrinsics.get(&intrinsic_key);
     let llptr = PointerCast(cx, llptr, T_ptr(T_i8()));
@@ -2512,7 +2503,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
                 ast::foreign_item_const(*) => {
                     let typ = ty::node_id_to_type(tcx, ni.id);
                     let ident = token::ident_to_str(&ni.ident);
-                    let g = do str::as_c_str(*ident) |buf| {
+                    let g = do str::as_c_str(ident) |buf| {
                         unsafe {
                             llvm::LLVMAddGlobal(ccx.llmod,
                                                 type_of(ccx, typ),
@@ -2607,10 +2598,10 @@ pub fn trans_constant(ccx: @CrateContext, it: @ast::item) {
                 path_name(variant.node.name),
                 path_name(special_idents::descrim)
             ]);
-            let s = @mangle_exported_name(ccx, p, ty::mk_int());
+            let s = mangle_exported_name(ccx, p, ty::mk_int()).to_managed();
             let disr_val = vi[i].disr_val;
             note_unique_llvm_symbol(ccx, s);
-            let discrim_gvar = str::as_c_str(*s, |buf| {
+            let discrim_gvar = str::as_c_str(s, |buf| {
                 unsafe {
                     llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
                 }
@@ -2649,7 +2640,7 @@ pub fn p2i(ccx: @CrateContext, v: ValueRef) -> ValueRef {
     }
 }
 
-pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> {
+pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
     let T_memcpy32_args: ~[TypeRef] =
         ~[T_ptr(T_i8()), T_ptr(T_i8()), T_i32(), T_i32(), T_i1()];
     let T_memcpy64_args: ~[TypeRef] =
@@ -2783,80 +2774,80 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> {
                                 T_fn([T_i64()], T_i64()));
 
     let mut intrinsics = HashMap::new();
-    intrinsics.insert(~"llvm.gcroot", gcroot);
-    intrinsics.insert(~"llvm.gcread", gcread);
-    intrinsics.insert(~"llvm.memcpy.p0i8.p0i8.i32", memcpy32);
-    intrinsics.insert(~"llvm.memcpy.p0i8.p0i8.i64", memcpy64);
-    intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i32", memmove32);
-    intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i64", memmove64);
-    intrinsics.insert(~"llvm.memset.p0i8.i32", memset32);
-    intrinsics.insert(~"llvm.memset.p0i8.i64", memset64);
-    intrinsics.insert(~"llvm.trap", trap);
-    intrinsics.insert(~"llvm.frameaddress", frameaddress);
-    intrinsics.insert(~"llvm.sqrt.f32", sqrtf32);
-    intrinsics.insert(~"llvm.sqrt.f64", sqrtf64);
-    intrinsics.insert(~"llvm.powi.f32", powif32);
-    intrinsics.insert(~"llvm.powi.f64", powif64);
-    intrinsics.insert(~"llvm.sin.f32", sinf32);
-    intrinsics.insert(~"llvm.sin.f64", sinf64);
-    intrinsics.insert(~"llvm.cos.f32", cosf32);
-    intrinsics.insert(~"llvm.cos.f64", cosf64);
-    intrinsics.insert(~"llvm.pow.f32", powf32);
-    intrinsics.insert(~"llvm.pow.f64", powf64);
-    intrinsics.insert(~"llvm.exp.f32", expf32);
-    intrinsics.insert(~"llvm.exp.f64", expf64);
-    intrinsics.insert(~"llvm.exp2.f32", exp2f32);
-    intrinsics.insert(~"llvm.exp2.f64", exp2f64);
-    intrinsics.insert(~"llvm.log.f32", logf32);
-    intrinsics.insert(~"llvm.log.f64", logf64);
-    intrinsics.insert(~"llvm.log10.f32", log10f32);
-    intrinsics.insert(~"llvm.log10.f64", log10f64);
-    intrinsics.insert(~"llvm.log2.f32", log2f32);
-    intrinsics.insert(~"llvm.log2.f64", log2f64);
-    intrinsics.insert(~"llvm.fma.f32", fmaf32);
-    intrinsics.insert(~"llvm.fma.f64", fmaf64);
-    intrinsics.insert(~"llvm.fabs.f32", fabsf32);
-    intrinsics.insert(~"llvm.fabs.f64", fabsf64);
-    intrinsics.insert(~"llvm.floor.f32", floorf32);
-    intrinsics.insert(~"llvm.floor.f64", floorf64);
-    intrinsics.insert(~"llvm.ceil.f32", ceilf32);
-    intrinsics.insert(~"llvm.ceil.f64", ceilf64);
-    intrinsics.insert(~"llvm.trunc.f32", truncf32);
-    intrinsics.insert(~"llvm.trunc.f64", truncf64);
-    intrinsics.insert(~"llvm.ctpop.i8", ctpop8);
-    intrinsics.insert(~"llvm.ctpop.i16", ctpop16);
-    intrinsics.insert(~"llvm.ctpop.i32", ctpop32);
-    intrinsics.insert(~"llvm.ctpop.i64", ctpop64);
-    intrinsics.insert(~"llvm.ctlz.i8", ctlz8);
-    intrinsics.insert(~"llvm.ctlz.i16", ctlz16);
-    intrinsics.insert(~"llvm.ctlz.i32", ctlz32);
-    intrinsics.insert(~"llvm.ctlz.i64", ctlz64);
-    intrinsics.insert(~"llvm.cttz.i8", cttz8);
-    intrinsics.insert(~"llvm.cttz.i16", cttz16);
-    intrinsics.insert(~"llvm.cttz.i32", cttz32);
-    intrinsics.insert(~"llvm.cttz.i64", cttz64);
-    intrinsics.insert(~"llvm.bswap.i16", bswap16);
-    intrinsics.insert(~"llvm.bswap.i32", bswap32);
-    intrinsics.insert(~"llvm.bswap.i64", bswap64);
+    intrinsics.insert("llvm.gcroot", gcroot);
+    intrinsics.insert("llvm.gcread", gcread);
+    intrinsics.insert("llvm.memcpy.p0i8.p0i8.i32", memcpy32);
+    intrinsics.insert("llvm.memcpy.p0i8.p0i8.i64", memcpy64);
+    intrinsics.insert("llvm.memmove.p0i8.p0i8.i32", memmove32);
+    intrinsics.insert("llvm.memmove.p0i8.p0i8.i64", memmove64);
+    intrinsics.insert("llvm.memset.p0i8.i32", memset32);
+    intrinsics.insert("llvm.memset.p0i8.i64", memset64);
+    intrinsics.insert("llvm.trap", trap);
+    intrinsics.insert("llvm.frameaddress", frameaddress);
+    intrinsics.insert("llvm.sqrt.f32", sqrtf32);
+    intrinsics.insert("llvm.sqrt.f64", sqrtf64);
+    intrinsics.insert("llvm.powi.f32", powif32);
+    intrinsics.insert("llvm.powi.f64", powif64);
+    intrinsics.insert("llvm.sin.f32", sinf32);
+    intrinsics.insert("llvm.sin.f64", sinf64);
+    intrinsics.insert("llvm.cos.f32", cosf32);
+    intrinsics.insert("llvm.cos.f64", cosf64);
+    intrinsics.insert("llvm.pow.f32", powf32);
+    intrinsics.insert("llvm.pow.f64", powf64);
+    intrinsics.insert("llvm.exp.f32", expf32);
+    intrinsics.insert("llvm.exp.f64", expf64);
+    intrinsics.insert("llvm.exp2.f32", exp2f32);
+    intrinsics.insert("llvm.exp2.f64", exp2f64);
+    intrinsics.insert("llvm.log.f32", logf32);
+    intrinsics.insert("llvm.log.f64", logf64);
+    intrinsics.insert("llvm.log10.f32", log10f32);
+    intrinsics.insert("llvm.log10.f64", log10f64);
+    intrinsics.insert("llvm.log2.f32", log2f32);
+    intrinsics.insert("llvm.log2.f64", log2f64);
+    intrinsics.insert("llvm.fma.f32", fmaf32);
+    intrinsics.insert("llvm.fma.f64", fmaf64);
+    intrinsics.insert("llvm.fabs.f32", fabsf32);
+    intrinsics.insert("llvm.fabs.f64", fabsf64);
+    intrinsics.insert("llvm.floor.f32", floorf32);
+    intrinsics.insert("llvm.floor.f64", floorf64);
+    intrinsics.insert("llvm.ceil.f32", ceilf32);
+    intrinsics.insert("llvm.ceil.f64", ceilf64);
+    intrinsics.insert("llvm.trunc.f32", truncf32);
+    intrinsics.insert("llvm.trunc.f64", truncf64);
+    intrinsics.insert("llvm.ctpop.i8", ctpop8);
+    intrinsics.insert("llvm.ctpop.i16", ctpop16);
+    intrinsics.insert("llvm.ctpop.i32", ctpop32);
+    intrinsics.insert("llvm.ctpop.i64", ctpop64);
+    intrinsics.insert("llvm.ctlz.i8", ctlz8);
+    intrinsics.insert("llvm.ctlz.i16", ctlz16);
+    intrinsics.insert("llvm.ctlz.i32", ctlz32);
+    intrinsics.insert("llvm.ctlz.i64", ctlz64);
+    intrinsics.insert("llvm.cttz.i8", cttz8);
+    intrinsics.insert("llvm.cttz.i16", cttz16);
+    intrinsics.insert("llvm.cttz.i32", cttz32);
+    intrinsics.insert("llvm.cttz.i64", cttz64);
+    intrinsics.insert("llvm.bswap.i16", bswap16);
+    intrinsics.insert("llvm.bswap.i32", bswap32);
+    intrinsics.insert("llvm.bswap.i64", bswap64);
 
     return intrinsics;
 }
 
 pub fn declare_dbg_intrinsics(llmod: ModuleRef,
-                              intrinsics: &mut HashMap<~str, ValueRef>) {
+                              intrinsics: &mut HashMap<&'static str, ValueRef>) {
     let declare =
         decl_cdecl_fn(llmod, "llvm.dbg.declare",
                       T_fn([T_metadata(), T_metadata()], T_void()));
     let value =
         decl_cdecl_fn(llmod, "llvm.dbg.value",
                       T_fn([T_metadata(), T_i64(), T_metadata()], T_void()));
-    intrinsics.insert(~"llvm.dbg.declare", declare);
-    intrinsics.insert(~"llvm.dbg.value", value);
+    intrinsics.insert("llvm.dbg.declare", declare);
+    intrinsics.insert("llvm.dbg.value", value);
 }
 
 pub fn trap(bcx: block) {
     let v: ~[ValueRef] = ~[];
-    match bcx.ccx().intrinsics.find(&~"llvm.trap") {
+    match bcx.ccx().intrinsics.find(& &"llvm.trap") {
       Some(&x) => { Call(bcx, x, v); },
       _ => bcx.sess().bug("unbound llvm.trap in trap")
     }
@@ -2891,7 +2882,7 @@ pub fn create_module_map(ccx: @CrateContext) -> ValueRef {
     lib::llvm::SetLinkage(map, lib::llvm::InternalLinkage);
     let mut elts: ~[ValueRef] = ~[];
     for ccx.module_data.each |key, &val| {
-        let elt = C_struct([p2i(ccx, C_cstr(ccx, @/*bad*/ copy *key)),
+        let elt = C_struct([p2i(ccx, C_cstr(ccx, /* bad */key.to_managed())),
                             p2i(ccx, val)]);
         elts.push(elt);
     }
@@ -2934,9 +2925,10 @@ pub fn fill_crate_map(ccx: @CrateContext, map: ValueRef) {
     let cstore = ccx.sess.cstore;
     while cstore::have_crate_data(cstore, i) {
         let cdata = cstore::get_crate_data(cstore, i);
-        let nm = ~"_rust_crate_map_" + *cdata.name +
-            "_" + *cstore::get_crate_vers(cstore, i) +
-            "_" + *cstore::get_crate_hash(cstore, i);
+        let nm = fmt!("_rust_crate_map_%s_%s_%s",
+                      cdata.name,
+                      cstore::get_crate_vers(cstore, i),
+                      cstore::get_crate_hash(cstore, i));
         let cr = str::as_c_str(nm, |buf| {
             unsafe {
                 llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 6150364e552..7e47fc47bff 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -165,7 +165,7 @@ pub struct CrateContext {
      td: TargetData,
      tn: @TypeNames,
      externs: ExternMap,
-     intrinsics: HashMap<~str, ValueRef>,
+     intrinsics: HashMap<&'static str, ValueRef>,
      item_vals: @mut HashMap<ast::node_id, ValueRef>,
      exp_map2: resolve::ExportMap2,
      reachable: reachable::map,
@@ -173,7 +173,7 @@ pub struct CrateContext {
      link_meta: LinkMeta,
      enum_sizes: @mut HashMap<ty::t, uint>,
      discrims: @mut HashMap<ast::def_id, ValueRef>,
-     discrim_symbols: @mut HashMap<ast::node_id, @~str>,
+     discrim_symbols: @mut HashMap<ast::node_id, @str>,
      tydescs: @mut HashMap<ty::t, @mut tydesc_info>,
      // Set when running emit_tydescs to enforce that no more tydescs are
      // created.
@@ -188,7 +188,7 @@ pub struct CrateContext {
      // Cache generated vtables
      vtables: @mut HashMap<mono_id, ValueRef>,
      // Cache of constant strings,
-     const_cstr_cache: @mut HashMap<@~str, ValueRef>,
+     const_cstr_cache: @mut HashMap<@str, ValueRef>,
 
      // Reverse-direction for const ptrs cast from globals.
      // Key is an int, cast from a ValueRef holding a *T,
@@ -215,7 +215,7 @@ pub struct CrateContext {
      symbol_hasher: @mut hash::State,
      type_hashcodes: @mut HashMap<ty::t, @str>,
      type_short_names: @mut HashMap<ty::t, ~str>,
-     all_llvm_symbols: @mut HashSet<@~str>,
+     all_llvm_symbols: @mut HashSet<@str>,
      tcx: ty::ctxt,
      maps: astencode::Maps,
      stats: @mut Stats,
@@ -1176,14 +1176,14 @@ pub fn C_u8(i: uint) -> ValueRef {
 
 // This is a 'c-like' raw string, which differs from
 // our boxed-and-length-annotated strings.
-pub fn C_cstr(cx: @CrateContext, s: @~str) -> ValueRef {
+pub fn C_cstr(cx: @CrateContext, s: @str) -> ValueRef {
     unsafe {
         match cx.const_cstr_cache.find(&s) {
             Some(&llval) => return llval,
             None => ()
         }
 
-        let sc = do str::as_c_str(*s) |buf| {
+        let sc = do str::as_c_str(s) |buf| {
             llvm::LLVMConstStringInContext(cx.llcx, buf, s.len() as c_uint,
                                            False)
         };
@@ -1202,7 +1202,7 @@ pub fn C_cstr(cx: @CrateContext, s: @~str) -> ValueRef {
 
 // NB: Do not use `do_spill_noroot` to make this into a constant string, or
 // you will be kicked off fast isel. See issue #4352 for an example of this.
-pub fn C_estr_slice(cx: @CrateContext, s: @~str) -> ValueRef {
+pub fn C_estr_slice(cx: @CrateContext, s: @str) -> ValueRef {
     unsafe {
         let len = s.len();
         let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s), T_ptr(T_i8()));
@@ -1441,7 +1441,7 @@ pub fn path_str(sess: session::Session, p: &[path_elt]) -> ~str {
             ast_map::path_name(s) | ast_map::path_mod(s) => {
                 if first { first = false; }
                 else { r += "::"; }
-                r += *sess.str_of(s);
+                r += sess.str_of(s);
             }
         }
     }
@@ -1564,7 +1564,7 @@ pub fn dummy_substs(tps: ~[ty::t]) -> ty::substs {
 pub fn filename_and_line_num_from_span(bcx: block,
                                        span: span) -> (ValueRef, ValueRef) {
     let loc = bcx.sess().parse_sess.cm.lookup_char_pos(span.lo);
-    let filename_cstr = C_cstr(bcx.ccx(), @/*bad*/copy loc.file.name);
+    let filename_cstr = C_cstr(bcx.ccx(), loc.file.name);
     let filename = build::PointerCast(bcx, filename_cstr, T_ptr(T_i8()));
     let line = C_int(bcx.ccx(), loc.line as int);
     (filename, line)
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index 62704fd1eb0..39360f0d3fc 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -54,12 +54,12 @@ pub fn const_lit(cx: @CrateContext, e: @ast::expr, lit: ast::lit)
                         ty_to_str(cx.tcx, lit_int_ty)))
         }
       }
-      ast::lit_float(fs, t) => C_floating(/*bad*/copy *fs, T_float_ty(cx, t)),
+      ast::lit_float(fs, t) => C_floating(fs, T_float_ty(cx, t)),
       ast::lit_float_unsuffixed(fs) => {
         let lit_float_ty = ty::node_id_to_type(cx.tcx, e.id);
         match ty::get(lit_float_ty).sty {
           ty::ty_float(t) => {
-            C_floating(/*bad*/copy *fs, T_float_ty(cx, t))
+            C_floating(fs, T_float_ty(cx, t))
           }
           _ => {
             cx.sess.span_bug(lit.span,
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index 8c6dbb009f5..fe3e2940907 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -348,13 +348,13 @@ pub fn trans_fail_expr(bcx: block,
                     ppaux::ty_to_str(tcx, arg_datum.ty));
             }
         }
-        _ => trans_fail(bcx, sp_opt, @~"explicit failure")
+        _ => trans_fail(bcx, sp_opt, @"explicit failure")
     }
 }
 
 pub fn trans_fail(bcx: block,
                   sp_opt: Option<span>,
-                  fail_str: @~str)
+                  fail_str: @str)
                -> block {
     let _icx = bcx.insn_ctxt("trans_fail");
     let V_fail_str = C_cstr(bcx.ccx(), fail_str);
@@ -371,11 +371,11 @@ fn trans_fail_value(bcx: block,
       Some(sp) => {
         let sess = bcx.sess();
         let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
-        (C_cstr(bcx.ccx(), @/*bad*/ copy loc.file.name),
+        (C_cstr(bcx.ccx(), loc.file.name),
          loc.line as int)
       }
       None => {
-        (C_cstr(bcx.ccx(), @~"<runtime>"), 0)
+        (C_cstr(bcx.ccx(), @"<runtime>"), 0)
       }
     };
     let V_str = PointerCast(bcx, V_fail_str, T_ptr(T_i8()));
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index 840ced3d0cd..3bb9d4abab0 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -316,7 +316,7 @@ fn create_block(cx: block) -> @Metadata<BlockMetadata> {
         None => create_function(cx.fcx).node,
         Some(bcx) => create_block(bcx).node
     };
-    let file_node = create_file(cx.ccx(), fname);
+    let file_node = create_file(cx.ccx(), /* bad */ fname.to_owned());
     let unique_id = match cache.find(&LexicalBlockTag) {
       option::Some(v) => v.len() as int,
       option::None => 0
@@ -383,7 +383,7 @@ fn create_basic_type(cx: @CrateContext, t: ty::t, span: span)
     };
 
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let cu_node = create_compile_unit(cx);
     let (size, align) = size_and_align_of(cx, t);
     let lldata = ~[lltag(tg),
@@ -420,7 +420,7 @@ fn create_pointer_type(cx: @CrateContext, t: ty::t, span: span,
     }*/
     let (size, align) = size_and_align_of(cx, t);
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     //let cu_node = create_compile_unit(cx, fname);
     let name = ty_to_str(cx.tcx, t);
     let llnode = create_derived_type(tg, file_node.node, name, 0, size * 8,
@@ -438,7 +438,7 @@ fn create_pointer_type(cx: @CrateContext, t: ty::t, span: span,
 
 struct StructCtxt {
     file: ValueRef,
-    name: @~str,
+    name: @str,
     line: int,
     members: ~[ValueRef],
     total_size: int,
@@ -447,7 +447,7 @@ struct StructCtxt {
 
 fn finish_structure(cx: @mut StructCtxt) -> ValueRef {
     return create_composite_type(StructureTypeTag,
-                                 *cx.name,
+                                 cx.name,
                                  cx.file,
                                  cx.line,
                                  cx.total_size,
@@ -457,7 +457,7 @@ fn finish_structure(cx: @mut StructCtxt) -> ValueRef {
                                  Some(/*bad*/copy cx.members));
 }
 
-fn create_structure(file: @Metadata<FileMetadata>, name: @~str, line: int)
+fn create_structure(file: @Metadata<FileMetadata>, name: @str, line: int)
                  -> @mut StructCtxt {
     let cx = @mut StructCtxt {
         file: file.node,
@@ -501,14 +501,14 @@ fn add_member(cx: @mut StructCtxt,
 fn create_struct(cx: @CrateContext, t: ty::t, fields: ~[ty::field],
                  span: span) -> @Metadata<TyDescMetadata> {
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
-    let scx = create_structure(file_node, @ty_to_str(cx.tcx, t),
+    let file_node = create_file(cx, fname.to_owned());
+    let scx = create_structure(file_node, (ty_to_str(cx.tcx, t)).to_managed(),
                                line_from_span(cx.sess.codemap, span) as int);
     for fields.each |field| {
         let field_t = field.mt.ty;
         let ty_md = create_ty(cx, field_t, span);
         let (size, align) = size_and_align_of(cx, field_t);
-        add_member(scx, *cx.sess.str_of(field.ident),
+        add_member(scx, cx.sess.str_of(field.ident),
                    line_from_span(cx.sess.codemap, span) as int,
                    size as int, align as int, ty_md.node);
     }
@@ -524,7 +524,7 @@ fn create_struct(cx: @CrateContext, t: ty::t, fields: ~[ty::field],
 fn create_tuple(cx: @CrateContext, t: ty::t, elements: &[ty::t], span: span)
     -> @Metadata<TyDescMetadata> {
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let scx = create_structure(file_node,
                                cx.sess.str_of(
                                    ((/*bad*/copy cx.dbg_cx).get().names)
@@ -566,12 +566,12 @@ fn create_boxed_type(cx: @CrateContext, contents: ty::t,
       option::None {}
     }*/
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     //let cu_node = create_compile_unit_metadata(cx, fname);
     let int_t = ty::mk_int();
     let refcount_type = create_basic_type(cx, int_t, span);
     let name = ty_to_str(cx.tcx, contents);
-    let scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
+    let scx = create_structure(file_node, (fmt!("box<%s>", name)).to_managed(), 0);
     add_member(scx, "refcnt", 0, sys::size_of::<uint>() as int,
                sys::min_align_of::<uint>() as int, refcount_type.node);
     // the tydesc and other pointers should be irrelevant to the
@@ -628,7 +628,7 @@ fn create_fixed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
                     len: int, span: span) -> @Metadata<TyDescMetadata> {
     let t_md = create_ty(cx, elem_t, span);
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let (size, align) = size_and_align_of(cx, elem_t);
     let subrange = llmdnode([lltag(SubrangeTag), lli64(0), lli64(len - 1)]);
     let name = fmt!("[%s]", ty_to_str(cx.tcx, elem_t));
@@ -647,10 +647,10 @@ fn create_boxed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
                     vec_ty_span: codemap::span)
     -> @Metadata<TyDescMetadata> {
     let fname = filename_from_span(cx, vec_ty_span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let elem_ty_md = create_ty(cx, elem_t, vec_ty_span);
     let vec_scx = create_structure(file_node,
-                               @/*bad*/ copy ty_to_str(cx.tcx, vec_t), 0);
+                               ty_to_str(cx.tcx, vec_t).to_managed(), 0);
     let size_t_type = create_basic_type(cx, ty::mk_uint(), vec_ty_span);
     add_member(vec_scx, "fill", 0, sys::size_of::<libc::size_t>() as int,
                sys::min_align_of::<libc::size_t>() as int, size_t_type.node);
@@ -673,7 +673,7 @@ fn create_boxed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
         }
     };
 
-    let box_scx = create_structure(file_node, @fmt!("box<%s>", name), 0);
+    let box_scx = create_structure(file_node, (fmt!("box<%s>", name)).to_managed(), 0);
     let int_t = ty::mk_int();
     let refcount_type = create_basic_type(cx, int_t, vec_ty_span);
     add_member(box_scx, "refcnt", 0, sys::size_of::<uint>() as int,
@@ -698,11 +698,11 @@ fn create_boxed_vec(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t,
 fn create_vec_slice(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t, span: span)
     -> @Metadata<TyDescMetadata> {
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let elem_ty_md = create_ty(cx, elem_t, span);
     let uint_type = create_basic_type(cx, ty::mk_uint(), span);
     let elem_ptr = create_pointer_type(cx, elem_t, span, elem_ty_md);
-    let scx = create_structure(file_node, @ty_to_str(cx.tcx, vec_t), 0);
+    let scx = create_structure(file_node, ty_to_str(cx.tcx, vec_t).to_managed(), 0);
     let (_, ptr_size, ptr_align) = voidptr();
     add_member(scx, "vec", 0, ptr_size, ptr_align, elem_ptr.node);
     add_member(scx, "length", 0, sys::size_of::<uint>() as int,
@@ -720,7 +720,7 @@ fn create_vec_slice(cx: @CrateContext, vec_t: ty::t, elem_t: ty::t, span: span)
 fn create_fn_ty(cx: @CrateContext, fn_ty: ty::t, inputs: ~[ty::t], output: ty::t,
                 span: span) -> @Metadata<TyDescMetadata> {
     let fname = filename_from_span(cx, span);
-    let file_node = create_file(cx, fname);
+    let file_node = create_file(cx, fname.to_owned());
     let (vp, _, _) = voidptr();
     let output_md = create_ty(cx, output, span);
     let output_ptr_md = create_pointer_type(cx, output, span, output_md);
@@ -817,8 +817,8 @@ fn create_ty(cx: @CrateContext, t: ty::t, span: span)
     }
 }
 
-fn filename_from_span(cx: @CrateContext, sp: codemap::span) -> ~str {
-    /*bad*/copy cx.sess.codemap.lookup_char_pos(sp.lo).file.name
+fn filename_from_span(cx: @CrateContext, sp: codemap::span) -> @str {
+    cx.sess.codemap.lookup_char_pos(sp.lo).file.name
 }
 
 fn create_var(type_tag: int, context: ValueRef, name: &str, file: ValueRef,
@@ -853,12 +853,12 @@ pub fn create_local_var(bcx: block, local: @ast::local)
     let loc = cx.sess.codemap.lookup_char_pos(local.span.lo);
     let ty = node_id_type(bcx, local.node.id);
     let tymd = create_ty(cx, ty, local.node.ty.span);
-    let filemd = create_file(cx, /*bad*/copy loc.file.name);
+    let filemd = create_file(cx, /*bad*/ loc.file.name.to_owned());
     let context = match bcx.parent {
         None => create_function(bcx.fcx).node,
         Some(_) => create_block(bcx).node
     };
-    let mdnode = create_var(tg, context, *cx.sess.str_of(name),
+    let mdnode = create_var(tg, context, cx.sess.str_of(name),
                             filemd.node, loc.line as int, tymd.node);
     let mdval = @Metadata {
         node: mdnode,
@@ -878,7 +878,7 @@ pub fn create_local_var(bcx: block, local: @ast::local)
         }
     };
     let declargs = ~[llmdnode([llptr]), mdnode];
-    trans::build::Call(bcx, *cx.intrinsics.get(&~"llvm.dbg.declare"),
+    trans::build::Call(bcx, *cx.intrinsics.get(&("llvm.dbg.declare")),
                        declargs);
     return mdval;
 }
@@ -896,12 +896,12 @@ pub fn create_arg(bcx: block, arg: ast::arg, sp: span)
     }
 
     let loc = cx.sess.codemap.lookup_char_pos(sp.lo);
-    if loc.file.name == ~"<intrinsic>" {
+    if "<intrinsic>" == loc.file.name {
         return None;
     }
     let ty = node_id_type(bcx, arg.id);
     let tymd = create_ty(cx, ty, arg.ty.span);
-    let filemd = create_file(cx, /*bad*/copy loc.file.name);
+    let filemd = create_file(cx, /* bad */ loc.file.name.to_owned());
     let context = create_function(bcx.fcx);
 
     match arg.pat.node {
@@ -910,7 +910,7 @@ pub fn create_arg(bcx: block, arg: ast::arg, sp: span)
             let mdnode = create_var(
                 tg,
                 context.node,
-                *cx.sess.str_of(*path.idents.last()),
+                cx.sess.str_of(*path.idents.last()),
                 filemd.node,
                 loc.line as int,
                 tymd.node
@@ -927,7 +927,7 @@ pub fn create_arg(bcx: block, arg: ast::arg, sp: span)
             let llptr = fcx.llargs.get_copy(&arg.id);
             let declargs = ~[llmdnode([llptr]), mdnode];
             trans::build::Call(bcx,
-                               *cx.intrinsics.get(&~"llvm.dbg.declare"),
+                               *cx.intrinsics.get(&("llvm.dbg.declare")),
                                declargs);
             return Some(mdval);
         }
@@ -1000,7 +1000,7 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> {
     }
 
     let loc = cx.sess.codemap.lookup_char_pos(sp.lo);
-    let file_node = create_file(cx, copy loc.file.name).node;
+    let file_node = create_file(cx, loc.file.name.to_owned()).node;
     let ty_node = if cx.sess.opts.extra_debuginfo {
         match ret_ty.node {
           ast::ty_nil => llnull(),
@@ -1017,9 +1017,9 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> {
     let fn_metadata = ~[lltag(SubprogramTag),
                        llunused(),
                        file_node,
-                       llstr(*cx.sess.str_of(ident)),
+                       llstr(cx.sess.str_of(ident)),
                         //XXX fully-qualified C++ name:
-                       llstr(*cx.sess.str_of(ident)),
+                       llstr(cx.sess.str_of(ident)),
                        llstr(""), //XXX MIPS name?????
                        file_node,
                        lli32(loc.line as int),
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 65755345ac3..13fc610e94a 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -452,7 +452,7 @@ fn trans_to_datum_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
 fn trans_rvalue_datum_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
     let _icx = bcx.insn_ctxt("trans_rvalue_datum_unadjusted");
 
-    trace_span!(bcx, expr.span, @shorten(bcx.expr_to_str(expr)));
+    trace_span!(bcx, expr.span, shorten(bcx.expr_to_str(expr)));
 
     match expr.node {
         ast::expr_path(_) | ast::expr_self => {
@@ -507,7 +507,7 @@ fn trans_rvalue_stmt_unadjusted(bcx: block, expr: @ast::expr) -> block {
         return bcx;
     }
 
-    trace_span!(bcx, expr.span, @shorten(bcx.expr_to_str(expr)));
+    trace_span!(bcx, expr.span, shorten(bcx.expr_to_str(expr)));
 
     match expr.node {
         ast::expr_break(label_opt) => {
@@ -560,7 +560,7 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
     let _icx = bcx.insn_ctxt("trans_rvalue_dps_unadjusted");
     let tcx = bcx.tcx();
 
-    trace_span!(bcx, expr.span, @shorten(bcx.expr_to_str(expr)));
+    trace_span!(bcx, expr.span, shorten(bcx.expr_to_str(expr)));
 
     match expr.node {
         ast::expr_paren(e) => {
@@ -821,7 +821,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
     debug!("trans_lvalue(expr=%s)", bcx.expr_to_str(expr));
     let _indenter = indenter();
 
-    trace_span!(bcx, expr.span, @shorten(bcx.expr_to_str(expr)));
+    trace_span!(bcx, expr.span, shorten(bcx.expr_to_str(expr)));
 
     return match expr.node {
         ast::expr_paren(e) => {
@@ -1703,6 +1703,6 @@ fn trans_assign_op(bcx: block,
     return result_datum.copy_to_datum(bcx, DROP_EXISTING, dst_datum);
 }
 
-fn shorten(x: ~str) -> ~str {
-    if x.char_len() > 60 { x.slice_chars(0, 60).to_owned() } else { x }
+fn shorten(x: &str) -> @str {
+    (if x.char_len() > 60 {x.slice_chars(0, 60)} else {x}).to_managed()
 }
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index dfcf364233b..094c202b121 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -55,7 +55,7 @@ fn abi_info(ccx: @CrateContext) -> @cabi::ABIInfo {
     }
 }
 
-pub fn link_name(ccx: @CrateContext, i: @ast::foreign_item) -> @~str {
+pub fn link_name(ccx: @CrateContext, i: @ast::foreign_item) -> @str {
      match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
         None => ccx.sess.str_of(i.ident),
         Some(ln) => ln,
@@ -345,7 +345,7 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
             }
             ast::foreign_item_const(*) => {
                 let ident = token::ident_to_str(&foreign_item.ident);
-                ccx.item_symbols.insert(foreign_item.id, copy *ident);
+                ccx.item_symbols.insert(foreign_item.id, /* bad */ident.to_owned());
             }
         }
     }
@@ -403,9 +403,9 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
         }
 
         let lname = link_name(ccx, foreign_item);
-        let llbasefn = base_fn(ccx, *lname, tys, cc);
+        let llbasefn = base_fn(ccx, lname, tys, cc);
         // Name the shim function
-        let shim_name = *lname + "__c_stack_shim";
+        let shim_name = fmt!("%s__c_stack_shim", lname);
         build_shim_fn_(ccx,
                        shim_name,
                        llbasefn,
@@ -433,12 +433,12 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
                        item: @ast::foreign_item,
                        tys: &ShimTypes,
                        cc: lib::llvm::CallConv) {
-        debug!("build_direct_fn(%s)", *link_name(ccx, item));
+        debug!("build_direct_fn(%s)", link_name(ccx, item));
 
         let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
         let bcx = top_scope_block(fcx, None);
         let lltop = bcx.llbb;
-        let llbasefn = base_fn(ccx, *link_name(ccx, item), tys, cc);
+        let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
         let ty = ty::lookup_item_type(ccx.tcx,
                                       ast_util::local_def(item.id)).ty;
         let ret_ty = ty::ty_fn_ret(ty);
@@ -460,12 +460,12 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
                          item: @ast::foreign_item,
                          tys: &ShimTypes,
                          cc: lib::llvm::CallConv) {
-        debug!("build_fast_ffi_fn(%s)", *link_name(ccx, item));
+        debug!("build_fast_ffi_fn(%s)", link_name(ccx, item));
 
         let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
         let bcx = top_scope_block(fcx, None);
         let lltop = bcx.llbb;
-        let llbasefn = base_fn(ccx, *link_name(ccx, item), tys, cc);
+        let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
         set_no_inline(fcx.llfn);
         set_fixed_stack_segment(fcx.llfn);
         let ty = ty::lookup_item_type(ccx.tcx,
@@ -553,7 +553,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                        substs: @param_substs,
                        attributes: &[ast::attribute],
                        ref_id: Option<ast::node_id>) {
-    debug!("trans_intrinsic(item.ident=%s)", *ccx.sess.str_of(item.ident));
+    debug!("trans_intrinsic(item.ident=%s)", ccx.sess.str_of(item.ident));
 
     let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx, item.id));
 
@@ -574,8 +574,8 @@ pub fn trans_intrinsic(ccx: @CrateContext,
     let mut bcx = top_scope_block(fcx, None);
     let lltop = bcx.llbb;
     let first_real_arg = fcx.arg_pos(0u);
-    match *ccx.sess.str_of(item.ident) {
-        ~"atomic_cxchg" => {
+    match ccx.sess.str_of(item.ident).as_slice() {
+        "atomic_cxchg" => {
             let old = AtomicCmpXchg(bcx,
                                     get_param(decl, first_real_arg),
                                     get_param(decl, first_real_arg + 1u),
@@ -583,7 +583,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                     SequentiallyConsistent);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_cxchg_acq" => {
+        "atomic_cxchg_acq" => {
             let old = AtomicCmpXchg(bcx,
                                     get_param(decl, first_real_arg),
                                     get_param(decl, first_real_arg + 1u),
@@ -591,7 +591,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                     Acquire);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_cxchg_rel" => {
+        "atomic_cxchg_rel" => {
             let old = AtomicCmpXchg(bcx,
                                     get_param(decl, first_real_arg),
                                     get_param(decl, first_real_arg + 1u),
@@ -599,100 +599,100 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                     Release);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_load" => {
+        "atomic_load" => {
             let old = AtomicLoad(bcx,
                                  get_param(decl, first_real_arg),
                                  SequentiallyConsistent);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_load_acq" => {
+        "atomic_load_acq" => {
             let old = AtomicLoad(bcx,
                                  get_param(decl, first_real_arg),
                                  Acquire);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_store" => {
+        "atomic_store" => {
             AtomicStore(bcx,
                         get_param(decl, first_real_arg + 1u),
                         get_param(decl, first_real_arg),
                         SequentiallyConsistent);
         }
-        ~"atomic_store_rel" => {
+        "atomic_store_rel" => {
             AtomicStore(bcx,
                         get_param(decl, first_real_arg + 1u),
                         get_param(decl, first_real_arg),
                         Release);
         }
-        ~"atomic_xchg" => {
+        "atomic_xchg" => {
             let old = AtomicRMW(bcx, Xchg,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 SequentiallyConsistent);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xchg_acq" => {
+        "atomic_xchg_acq" => {
             let old = AtomicRMW(bcx, Xchg,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Acquire);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xchg_rel" => {
+        "atomic_xchg_rel" => {
             let old = AtomicRMW(bcx, Xchg,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Release);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xadd" => {
+        "atomic_xadd" => {
             let old = AtomicRMW(bcx, lib::llvm::Add,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 SequentiallyConsistent);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xadd_acq" => {
+        "atomic_xadd_acq" => {
             let old = AtomicRMW(bcx, lib::llvm::Add,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Acquire);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xadd_rel" => {
+        "atomic_xadd_rel" => {
             let old = AtomicRMW(bcx, lib::llvm::Add,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Release);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xsub" => {
+        "atomic_xsub" => {
             let old = AtomicRMW(bcx, lib::llvm::Sub,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 SequentiallyConsistent);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xsub_acq" => {
+        "atomic_xsub_acq" => {
             let old = AtomicRMW(bcx, lib::llvm::Sub,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Acquire);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_xsub_rel" => {
+        "atomic_xsub_rel" => {
             let old = AtomicRMW(bcx, lib::llvm::Sub,
                                 get_param(decl, first_real_arg),
                                 get_param(decl, first_real_arg + 1u),
                                 Release);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"size_of" => {
+        "size_of" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             Store(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty)),
                   fcx.llretptr.get());
         }
-        ~"move_val" => {
+        "move_val" => {
             // Create a datum reflecting the value being moved.
             // Use `appropriate_mode` so that the datum is by ref
             // if the value is non-immediate. Note that, with
@@ -705,7 +705,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             bcx = src.move_to(bcx, DROP_EXISTING,
                               get_param(decl, first_real_arg));
         }
-        ~"move_val_init" => {
+        "move_val_init" => {
             // See comments for `"move_val"`.
             let tp_ty = substs.tys[0];
             let mode = appropriate_mode(tp_ty);
@@ -713,19 +713,19 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                              ty: tp_ty, mode: mode};
             bcx = src.move_to(bcx, INIT, get_param(decl, first_real_arg));
         }
-        ~"min_align_of" => {
+        "min_align_of" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             Store(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty)),
                   fcx.llretptr.get());
         }
-        ~"pref_align_of"=> {
+        "pref_align_of"=> {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             Store(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty)),
                   fcx.llretptr.get());
         }
-        ~"get_tydesc" => {
+        "get_tydesc" => {
             let tp_ty = substs.tys[0];
             let static_ti = get_tydesc(ccx, tp_ty);
             glue::lazily_emit_all_tydesc_glue(ccx, static_ti);
@@ -735,18 +735,18 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let td = PointerCast(bcx, static_ti.tydesc, T_ptr(T_nil()));
             Store(bcx, td, fcx.llretptr.get());
         }
-        ~"init" => {
+        "init" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             if !ty::type_is_nil(tp_ty) {
                 Store(bcx, C_null(lltp_ty), fcx.llretptr.get());
             }
         }
-        ~"uninit" => {
+        "uninit" => {
             // Do nothing, this is effectively a no-op
         }
-        ~"forget" => {}
-        ~"transmute" => {
+        "forget" => {}
+        "transmute" => {
             let (in_type, out_type) = (substs.tys[0], substs.tys[1]);
             let llintype = type_of::type_of(ccx, in_type);
             let llouttype = type_of::type_of(ccx, out_type);
@@ -792,13 +792,13 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
             }
         }
-        ~"needs_drop" => {
+        "needs_drop" => {
             let tp_ty = substs.tys[0];
             Store(bcx,
                   C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)),
                   fcx.llretptr.get());
         }
-        ~"visit_tydesc" => {
+        "visit_tydesc" => {
             let td = get_param(decl, first_real_arg);
             let visitor = get_param(decl, first_real_arg + 1u);
             //let llvisitorptr = alloca(bcx, val_ty(visitor));
@@ -810,8 +810,8 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                         abi::tydesc_field_visit_glue,
                                         None);
         }
-        ~"frame_address" => {
-            let frameaddress = *ccx.intrinsics.get(&~"llvm.frameaddress");
+        "frame_address" => {
+            let frameaddress = *ccx.intrinsics.get(& &"llvm.frameaddress");
             let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]);
             let star_u8 = ty::mk_imm_ptr(
                 bcx.tcx(),
@@ -836,7 +836,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 |bcx| Callee {bcx: bcx, data: Closure(datum)},
                 ArgVals(arg_vals), Ignore, DontAutorefArg);
         }
-        ~"morestack_addr" => {
+        "morestack_addr" => {
             // XXX This is a hack to grab the address of this particular
             // native function. There should be a general in-language
             // way to do this
@@ -847,7 +847,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                              T_ptr(T_nil()));
             Store(bcx, morestack_addr, fcx.llretptr.get());
         }
-        ~"memcpy32" => {
+        "memcpy32" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -857,10 +857,10 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), T_ptr(T_i8()));
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memcpy.p0i8.p0i8.i32");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memcpy.p0i8.p0i8.i32");
             Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
         }
-        ~"memcpy64" => {
+        "memcpy64" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -870,10 +870,10 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), T_ptr(T_i8()));
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memcpy.p0i8.p0i8.i64");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memcpy.p0i8.p0i8.i64");
             Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
         }
-        ~"memmove32" => {
+        "memmove32" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -883,10 +883,10 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), T_ptr(T_i8()));
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memmove.p0i8.p0i8.i32");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memmove.p0i8.p0i8.i32");
             Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
         }
-        ~"memmove64" => {
+        "memmove64" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -896,10 +896,10 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), T_ptr(T_i8()));
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memmove.p0i8.p0i8.i64");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memmove.p0i8.p0i8.i64");
             Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
         }
-        ~"memset32" => {
+        "memset32" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -909,10 +909,10 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let val = get_param(decl, first_real_arg + 1);
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memset.p0i8.i32");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memset.p0i8.i32");
             Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, volatile]);
         }
-        ~"memset64" => {
+        "memset64" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
@@ -922,248 +922,248 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             let val = get_param(decl, first_real_arg + 1);
             let count = get_param(decl, first_real_arg + 2);
             let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(&~"llvm.memset.p0i8.i64");
+            let llfn = *bcx.ccx().intrinsics.get(& &"llvm.memset.p0i8.i64");
             Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, volatile]);
         }
-        ~"sqrtf32" => {
+        "sqrtf32" => {
             let x = get_param(decl, first_real_arg);
-            let sqrtf = *ccx.intrinsics.get(&~"llvm.sqrt.f32");
+            let sqrtf = *ccx.intrinsics.get(& &"llvm.sqrt.f32");
             Store(bcx, Call(bcx, sqrtf, [x]), fcx.llretptr.get());
         }
-        ~"sqrtf64" => {
+        "sqrtf64" => {
             let x = get_param(decl, first_real_arg);
-            let sqrtf = *ccx.intrinsics.get(&~"llvm.sqrt.f64");
+            let sqrtf = *ccx.intrinsics.get(& &"llvm.sqrt.f64");
             Store(bcx, Call(bcx, sqrtf, [x]), fcx.llretptr.get());
         }
-        ~"powif32" => {
+        "powif32" => {
             let a = get_param(decl, first_real_arg);
             let x = get_param(decl, first_real_arg + 1u);
-            let powif = *ccx.intrinsics.get(&~"llvm.powi.f32");
+            let powif = *ccx.intrinsics.get(& &"llvm.powi.f32");
             Store(bcx, Call(bcx, powif, [a, x]), fcx.llretptr.get());
         }
-        ~"powif64" => {
+        "powif64" => {
             let a = get_param(decl, first_real_arg);
             let x = get_param(decl, first_real_arg + 1u);
-            let powif = *ccx.intrinsics.get(&~"llvm.powi.f64");
+            let powif = *ccx.intrinsics.get(& &"llvm.powi.f64");
             Store(bcx, Call(bcx, powif, [a, x]), fcx.llretptr.get());
         }
-        ~"sinf32" => {
+        "sinf32" => {
             let x = get_param(decl, first_real_arg);
-            let sinf = *ccx.intrinsics.get(&~"llvm.sin.f32");
+            let sinf = *ccx.intrinsics.get(& &"llvm.sin.f32");
             Store(bcx, Call(bcx, sinf, [x]), fcx.llretptr.get());
         }
-        ~"sinf64" => {
+        "sinf64" => {
             let x = get_param(decl, first_real_arg);
-            let sinf = *ccx.intrinsics.get(&~"llvm.sin.f64");
+            let sinf = *ccx.intrinsics.get(& &"llvm.sin.f64");
             Store(bcx, Call(bcx, sinf, [x]), fcx.llretptr.get());
         }
-        ~"cosf32" => {
+        "cosf32" => {
             let x = get_param(decl, first_real_arg);
-            let cosf = *ccx.intrinsics.get(&~"llvm.cos.f32");
+            let cosf = *ccx.intrinsics.get(& &"llvm.cos.f32");
             Store(bcx, Call(bcx, cosf, [x]), fcx.llretptr.get());
         }
-        ~"cosf64" => {
+        "cosf64" => {
             let x = get_param(decl, first_real_arg);
-            let cosf = *ccx.intrinsics.get(&~"llvm.cos.f64");
+            let cosf = *ccx.intrinsics.get(& &"llvm.cos.f64");
             Store(bcx, Call(bcx, cosf, [x]), fcx.llretptr.get());
         }
-        ~"powf32" => {
+        "powf32" => {
             let a = get_param(decl, first_real_arg);
             let x = get_param(decl, first_real_arg + 1u);
-            let powf = *ccx.intrinsics.get(&~"llvm.pow.f32");
+            let powf = *ccx.intrinsics.get(& &"llvm.pow.f32");
             Store(bcx, Call(bcx, powf, [a, x]), fcx.llretptr.get());
         }
-        ~"powf64" => {
+        "powf64" => {
             let a = get_param(decl, first_real_arg);
             let x = get_param(decl, first_real_arg + 1u);
-            let powf = *ccx.intrinsics.get(&~"llvm.pow.f64");
+            let powf = *ccx.intrinsics.get(& &"llvm.pow.f64");
             Store(bcx, Call(bcx, powf, [a, x]), fcx.llretptr.get());
         }
-        ~"expf32" => {
+        "expf32" => {
             let x = get_param(decl, first_real_arg);
-            let expf = *ccx.intrinsics.get(&~"llvm.exp.f32");
+            let expf = *ccx.intrinsics.get(& &"llvm.exp.f32");
             Store(bcx, Call(bcx, expf, [x]), fcx.llretptr.get());
         }
-        ~"expf64" => {
+        "expf64" => {
             let x = get_param(decl, first_real_arg);
-            let expf = *ccx.intrinsics.get(&~"llvm.exp.f64");
+            let expf = *ccx.intrinsics.get(& &"llvm.exp.f64");
             Store(bcx, Call(bcx, expf, [x]), fcx.llretptr.get());
         }
-        ~"exp2f32" => {
+        "exp2f32" => {
             let x = get_param(decl, first_real_arg);
-            let exp2f = *ccx.intrinsics.get(&~"llvm.exp2.f32");
+            let exp2f = *ccx.intrinsics.get(& &"llvm.exp2.f32");
             Store(bcx, Call(bcx, exp2f, [x]), fcx.llretptr.get());
         }
-        ~"exp2f64" => {
+        "exp2f64" => {
             let x = get_param(decl, first_real_arg);
-            let exp2f = *ccx.intrinsics.get(&~"llvm.exp2.f64");
+            let exp2f = *ccx.intrinsics.get(& &"llvm.exp2.f64");
             Store(bcx, Call(bcx, exp2f, [x]), fcx.llretptr.get());
         }
-        ~"logf32" => {
+        "logf32" => {
             let x = get_param(decl, first_real_arg);
-            let logf = *ccx.intrinsics.get(&~"llvm.log.f32");
+            let logf = *ccx.intrinsics.get(& &"llvm.log.f32");
             Store(bcx, Call(bcx, logf, [x]), fcx.llretptr.get());
         }
-        ~"logf64" => {
+        "logf64" => {
             let x = get_param(decl, first_real_arg);
-            let logf = *ccx.intrinsics.get(&~"llvm.log.f64");
+            let logf = *ccx.intrinsics.get(& &"llvm.log.f64");
             Store(bcx, Call(bcx, logf, [x]), fcx.llretptr.get());
         }
-        ~"log10f32" => {
+        "log10f32" => {
             let x = get_param(decl, first_real_arg);
-            let log10f = *ccx.intrinsics.get(&~"llvm.log10.f32");
+            let log10f = *ccx.intrinsics.get(& &"llvm.log10.f32");
             Store(bcx, Call(bcx, log10f, [x]), fcx.llretptr.get());
         }
-        ~"log10f64" => {
+        "log10f64" => {
             let x = get_param(decl, first_real_arg);
-            let log10f = *ccx.intrinsics.get(&~"llvm.log10.f64");
+            let log10f = *ccx.intrinsics.get(& &"llvm.log10.f64");
             Store(bcx, Call(bcx, log10f, [x]), fcx.llretptr.get());
         }
-        ~"log2f32" => {
+        "log2f32" => {
             let x = get_param(decl, first_real_arg);
-            let log2f = *ccx.intrinsics.get(&~"llvm.log2.f32");
+            let log2f = *ccx.intrinsics.get(& &"llvm.log2.f32");
             Store(bcx, Call(bcx, log2f, [x]), fcx.llretptr.get());
         }
-        ~"log2f64" => {
+        "log2f64" => {
             let x = get_param(decl, first_real_arg);
-            let log2f = *ccx.intrinsics.get(&~"llvm.log2.f64");
+            let log2f = *ccx.intrinsics.get(& &"llvm.log2.f64");
             Store(bcx, Call(bcx, log2f, [x]), fcx.llretptr.get());
         }
-        ~"fmaf32" => {
+        "fmaf32" => {
             let a = get_param(decl, first_real_arg);
             let b = get_param(decl, first_real_arg + 1u);
             let c = get_param(decl, first_real_arg + 2u);
-            let fmaf = *ccx.intrinsics.get(&~"llvm.fma.f32");
+            let fmaf = *ccx.intrinsics.get(& &"llvm.fma.f32");
             Store(bcx, Call(bcx, fmaf, [a, b, c]), fcx.llretptr.get());
         }
-        ~"fmaf64" => {
+        "fmaf64" => {
             let a = get_param(decl, first_real_arg);
             let b = get_param(decl, first_real_arg + 1u);
             let c = get_param(decl, first_real_arg + 2u);
-            let fmaf = *ccx.intrinsics.get(&~"llvm.fma.f64");
+            let fmaf = *ccx.intrinsics.get(& &"llvm.fma.f64");
             Store(bcx, Call(bcx, fmaf, [a, b, c]), fcx.llretptr.get());
         }
-        ~"fabsf32" => {
+        "fabsf32" => {
             let x = get_param(decl, first_real_arg);
-            let fabsf = *ccx.intrinsics.get(&~"llvm.fabs.f32");
+            let fabsf = *ccx.intrinsics.get(& &"llvm.fabs.f32");
             Store(bcx, Call(bcx, fabsf, [x]), fcx.llretptr.get());
         }
-        ~"fabsf64" => {
+        "fabsf64" => {
             let x = get_param(decl, first_real_arg);
-            let fabsf = *ccx.intrinsics.get(&~"llvm.fabs.f64");
+            let fabsf = *ccx.intrinsics.get(& &"llvm.fabs.f64");
             Store(bcx, Call(bcx, fabsf, [x]), fcx.llretptr.get());
         }
-        ~"floorf32" => {
+        "floorf32" => {
             let x = get_param(decl, first_real_arg);
-            let floorf = *ccx.intrinsics.get(&~"llvm.floor.f32");
+            let floorf = *ccx.intrinsics.get(& &"llvm.floor.f32");
             Store(bcx, Call(bcx, floorf, [x]), fcx.llretptr.get());
         }
-        ~"floorf64" => {
+        "floorf64" => {
             let x = get_param(decl, first_real_arg);
-            let floorf = *ccx.intrinsics.get(&~"llvm.floor.f64");
+            let floorf = *ccx.intrinsics.get(& &"llvm.floor.f64");
             Store(bcx, Call(bcx, floorf, [x]), fcx.llretptr.get());
         }
-        ~"ceilf32" => {
+        "ceilf32" => {
             let x = get_param(decl, first_real_arg);
-            let ceilf = *ccx.intrinsics.get(&~"llvm.ceil.f32");
+            let ceilf = *ccx.intrinsics.get(& &"llvm.ceil.f32");
             Store(bcx, Call(bcx, ceilf, [x]), fcx.llretptr.get());
         }
-        ~"ceilf64" => {
+        "ceilf64" => {
             let x = get_param(decl, first_real_arg);
-            let ceilf = *ccx.intrinsics.get(&~"llvm.ceil.f64");
+            let ceilf = *ccx.intrinsics.get(& &"llvm.ceil.f64");
             Store(bcx, Call(bcx, ceilf, [x]), fcx.llretptr.get());
         }
-        ~"truncf32" => {
+        "truncf32" => {
             let x = get_param(decl, first_real_arg);
-            let truncf = *ccx.intrinsics.get(&~"llvm.trunc.f32");
+            let truncf = *ccx.intrinsics.get(& &"llvm.trunc.f32");
             Store(bcx, Call(bcx, truncf, [x]), fcx.llretptr.get());
         }
-        ~"truncf64" => {
+        "truncf64" => {
             let x = get_param(decl, first_real_arg);
-            let truncf = *ccx.intrinsics.get(&~"llvm.trunc.f64");
+            let truncf = *ccx.intrinsics.get(& &"llvm.trunc.f64");
             Store(bcx, Call(bcx, truncf, [x]), fcx.llretptr.get());
         }
-        ~"ctpop8" => {
+        "ctpop8" => {
             let x = get_param(decl, first_real_arg);
-            let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i8");
+            let ctpop = *ccx.intrinsics.get(& &"llvm.ctpop.i8");
             Store(bcx, Call(bcx, ctpop, [x]), fcx.llretptr.get())
         }
-        ~"ctpop16" => {
+        "ctpop16" => {
             let x = get_param(decl, first_real_arg);
-            let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i16");
+            let ctpop = *ccx.intrinsics.get(& &"llvm.ctpop.i16");
             Store(bcx, Call(bcx, ctpop, [x]), fcx.llretptr.get())
         }
-        ~"ctpop32" => {
+        "ctpop32" => {
             let x = get_param(decl, first_real_arg);
-            let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i32");
+            let ctpop = *ccx.intrinsics.get(& &"llvm.ctpop.i32");
             Store(bcx, Call(bcx, ctpop, [x]), fcx.llretptr.get())
         }
-        ~"ctpop64" => {
+        "ctpop64" => {
             let x = get_param(decl, first_real_arg);
-            let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i64");
+            let ctpop = *ccx.intrinsics.get(& &"llvm.ctpop.i64");
             Store(bcx, Call(bcx, ctpop, [x]), fcx.llretptr.get())
         }
-        ~"ctlz8" => {
+        "ctlz8" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i8");
+            let ctlz = *ccx.intrinsics.get(& &"llvm.ctlz.i8");
             Store(bcx, Call(bcx, ctlz, [x, y]), fcx.llretptr.get())
         }
-        ~"ctlz16" => {
+        "ctlz16" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i16");
+            let ctlz = *ccx.intrinsics.get(& &"llvm.ctlz.i16");
             Store(bcx, Call(bcx, ctlz, [x, y]), fcx.llretptr.get())
         }
-        ~"ctlz32" => {
+        "ctlz32" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i32");
+            let ctlz = *ccx.intrinsics.get(& &"llvm.ctlz.i32");
             Store(bcx, Call(bcx, ctlz, [x, y]), fcx.llretptr.get())
         }
-        ~"ctlz64" => {
+        "ctlz64" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i64");
+            let ctlz = *ccx.intrinsics.get(& &"llvm.ctlz.i64");
             Store(bcx, Call(bcx, ctlz, [x, y]), fcx.llretptr.get())
         }
-        ~"cttz8" => {
+        "cttz8" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i8");
+            let cttz = *ccx.intrinsics.get(& &"llvm.cttz.i8");
             Store(bcx, Call(bcx, cttz, [x, y]), fcx.llretptr.get())
         }
-        ~"cttz16" => {
+        "cttz16" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i16");
+            let cttz = *ccx.intrinsics.get(& &"llvm.cttz.i16");
             Store(bcx, Call(bcx, cttz, [x, y]), fcx.llretptr.get())
         }
-        ~"cttz32" => {
+        "cttz32" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i32");
+            let cttz = *ccx.intrinsics.get(& &"llvm.cttz.i32");
             Store(bcx, Call(bcx, cttz, [x, y]), fcx.llretptr.get())
         }
-        ~"cttz64" => {
+        "cttz64" => {
             let x = get_param(decl, first_real_arg);
             let y = C_i1(false);
-            let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i64");
+            let cttz = *ccx.intrinsics.get(& &"llvm.cttz.i64");
             Store(bcx, Call(bcx, cttz, [x, y]), fcx.llretptr.get())
         }
-        ~"bswap16" => {
+        "bswap16" => {
             let x = get_param(decl, first_real_arg);
-            let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i16");
+            let cttz = *ccx.intrinsics.get(& &"llvm.bswap.i16");
             Store(bcx, Call(bcx, cttz, [x]), fcx.llretptr.get())
         }
-        ~"bswap32" => {
+        "bswap32" => {
             let x = get_param(decl, first_real_arg);
-            let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i32");
+            let cttz = *ccx.intrinsics.get(& &"llvm.bswap.i32");
             Store(bcx, Call(bcx, cttz, [x]), fcx.llretptr.get())
         }
-        ~"bswap64" => {
+        "bswap64" => {
             let x = get_param(decl, first_real_arg);
-            let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i64");
+            let cttz = *ccx.intrinsics.get(& &"llvm.bswap.i64");
             Store(bcx, Call(bcx, cttz, [x]), fcx.llretptr.get())
         }
         _ => {
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index e2f7dc086d0..c982b26fe84 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -686,10 +686,10 @@ pub fn declare_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info {
     let llsize = llsize_of(ccx, llty);
     let llalign = llalign_of(ccx, llty);
     let addrspace = declare_tydesc_addrspace(ccx, t);
-    let name = @mangle_internal_name_by_type_and_seq(ccx, t, "tydesc");
+    let name = mangle_internal_name_by_type_and_seq(ccx, t, "tydesc").to_managed();
     note_unique_llvm_symbol(ccx, name);
-    debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), *name);
-    let gvar = str::as_c_str(*name, |buf| {
+    debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), name);
+    let gvar = str::as_c_str(name, |buf| {
         unsafe {
             llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, buf)
         }
@@ -715,10 +715,10 @@ pub fn declare_generic_glue(ccx: @CrateContext, t: ty::t, llfnty: TypeRef,
                             name: ~str) -> ValueRef {
     let _icx = ccx.insn_ctxt("declare_generic_glue");
     let name = name;
-    let fn_nm = @mangle_internal_name_by_type_and_seq(ccx, t, (~"glue_" + name));
-    debug!("%s is for type %s", *fn_nm, ppaux::ty_to_str(ccx.tcx, t));
+    let fn_nm = mangle_internal_name_by_type_and_seq(ccx, t, (~"glue_" + name)).to_managed();
+    debug!("%s is for type %s", fn_nm, ppaux::ty_to_str(ccx.tcx, t));
     note_unique_llvm_symbol(ccx, fn_nm);
-    let llfn = decl_cdecl_fn(ccx.llmod, *fn_nm, llfnty);
+    let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty);
     set_glue_inlining(llfn, t);
     return llfn;
 }
diff --git a/src/librustc/middle/trans/machine.rs b/src/librustc/middle/trans/machine.rs
index bd3c630fbb7..d2a437a1872 100644
--- a/src/librustc/middle/trans/machine.rs
+++ b/src/librustc/middle/trans/machine.rs
@@ -139,7 +139,7 @@ pub fn static_size_of_enum(cx: @CrateContext, t: ty::t) -> uint {
                 });
 
                 debug!("static_size_of_enum: variant %s type %s",
-                       *cx.tcx.sess.str_of(variant.name),
+                       cx.tcx.sess.str_of(variant.name),
                        ty_str(cx.tn, T_struct(lltypes, false)));
 
                 let this_size = llsize_of_real(cx, T_struct(lltypes, false));
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index 9d8ef2e603b..2b9f559c099 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -339,7 +339,7 @@ pub fn trans_static_method_callee(bcx: block,
         }
     };
     debug!("trans_static_method_callee: method_id=%?, callee_id=%?, \
-            name=%s", method_id, callee_id, *ccx.sess.str_of(mname));
+            name=%s", method_id, callee_id, ccx.sess.str_of(mname));
 
     let vtbls = resolve_vtables_in_fn_ctxt(
         bcx.fcx, ccx.maps.vtable_map.get_copy(&callee_id));
@@ -791,7 +791,7 @@ pub fn make_vtable(ccx: @CrateContext,
 
         let tbl = C_struct(components);
         let vtable = ccx.sess.str_of((ccx.names)("vtable"));
-        let vt_gvar = do str::as_c_str(*vtable) |buf| {
+        let vt_gvar = do str::as_c_str(vtable) |buf| {
             llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl), buf)
         };
         llvm::LLVMSetInitializer(vt_gvar, tbl);
@@ -827,16 +827,15 @@ pub fn make_impl_vtable(bcx: block,
                                 ty::mk_bare_fn(tcx, copy im.fty));
         if im.generics.has_type_params() || ty::type_has_self(fty) {
             debug!("(making impl vtable) method has self or type params: %s",
-                   *tcx.sess.str_of(im.ident));
+                   tcx.sess.str_of(im.ident));
             C_null(T_ptr(T_nil()))
         } else {
             debug!("(making impl vtable) adding method to vtable: %s",
-                   *tcx.sess.str_of(im.ident));
+                   tcx.sess.str_of(im.ident));
             let m_id = method_with_name_or_default(ccx, impl_id, im.ident);
 
             trans_fn_ref_with_vtables(bcx, m_id, 0,
                                       substs, Some(vtables)).llfn
-
         }
     };
 
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 35ff3a56df4..54be98e4770 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -164,7 +164,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
     ccx.monomorphizing.insert(fn_id, depth + 1);
 
     let pt = vec::append(/*bad*/copy *pt,
-                         [path_name((ccx.names)(*ccx.sess.str_of(name)))]);
+                         [path_name((ccx.names)(ccx.sess.str_of(name)))]);
     let s = mangle_exported_name(ccx, /*bad*/copy pt, mono_ty);
 
     let mk_lldecl = || {
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index 38cc9ba69de..5c47cdbdb36 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -50,7 +50,7 @@ impl Reflector {
         C_int(self.bcx.ccx(), i)
     }
 
-    pub fn c_slice(&mut self, s: @~str) -> ValueRef {
+    pub fn c_slice(&mut self, s: @str) -> ValueRef {
         // We're careful to not use first class aggregates here because that
         // will kick us off fast isel. (Issue #4352.)
         let bcx = self.bcx;
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
index c009b03e5c2..0667b0ed7dc 100644
--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@@ -250,7 +250,7 @@ pub fn trans_slice_vstore(bcx: block,
 
 pub fn trans_lit_str(bcx: block,
                      lit_expr: @ast::expr,
-                     str_lit: @~str,
+                     str_lit: @str,
                      dest: Dest)
                   -> block {
     //!
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
index b2b11d544c1..d1402935e8d 100644
--- a/src/librustc/middle/trans/type_use.rs
+++ b/src/librustc/middle/trans/type_use.rs
@@ -118,43 +118,43 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
                                  _,
                                  _) => {
         if abi.is_intrinsic() {
-            let flags = match *cx.ccx.sess.str_of(i.ident) {
-                ~"size_of"  | ~"pref_align_of" | ~"min_align_of" |
-                ~"uninit"   | ~"init" | ~"transmute" | ~"move_val" |
-                ~"move_val_init" => use_repr,
+            let flags = match cx.ccx.sess.str_of(i.ident).as_slice() {
+                "size_of"  | "pref_align_of" | "min_align_of" |
+                "uninit"   | "init" | "transmute" | "move_val" |
+                "move_val_init" => use_repr,
 
-                ~"get_tydesc" | ~"needs_drop" => use_tydesc,
+                "get_tydesc" | "needs_drop" => use_tydesc,
 
-                ~"atomic_cxchg"    | ~"atomic_cxchg_acq"|
-                ~"atomic_cxchg_rel"| ~"atomic_load"     |
-                ~"atomic_load_acq" | ~"atomic_store"    |
-                ~"atomic_store_rel"| ~"atomic_xchg"     |
-                ~"atomic_xadd"     | ~"atomic_xsub"     |
-                ~"atomic_xchg_acq" | ~"atomic_xadd_acq" |
-                ~"atomic_xsub_acq" | ~"atomic_xchg_rel" |
-                ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => 0,
+                "atomic_cxchg"    | "atomic_cxchg_acq"|
+                "atomic_cxchg_rel"| "atomic_load"     |
+                "atomic_load_acq" | "atomic_store"    |
+                "atomic_store_rel"| "atomic_xchg"     |
+                "atomic_xadd"     | "atomic_xsub"     |
+                "atomic_xchg_acq" | "atomic_xadd_acq" |
+                "atomic_xsub_acq" | "atomic_xchg_rel" |
+                "atomic_xadd_rel" | "atomic_xsub_rel" => 0,
 
-                ~"visit_tydesc"  | ~"forget" | ~"frame_address" |
-                ~"morestack_addr" => 0,
+                "visit_tydesc"  | "forget" | "frame_address" |
+                "morestack_addr" => 0,
 
-                ~"memcpy32" | ~"memcpy64" | ~"memmove32" | ~"memmove64" |
-                ~"memset32" | ~"memset64" => use_repr,
+                "memcpy32" | "memcpy64" | "memmove32" | "memmove64" |
+                "memset32" | "memset64" => use_repr,
 
-                ~"sqrtf32" | ~"sqrtf64" | ~"powif32" | ~"powif64" |
-                ~"sinf32"  | ~"sinf64"  | ~"cosf32"  | ~"cosf64"  |
-                ~"powf32"  | ~"powf64"  | ~"expf32"  | ~"expf64"  |
-                ~"exp2f32" | ~"exp2f64" | ~"logf32"  | ~"logf64"  |
-                ~"log10f32"| ~"log10f64"| ~"log2f32" | ~"log2f64" |
-                ~"fmaf32"  | ~"fmaf64"  | ~"fabsf32" | ~"fabsf64" |
-                ~"floorf32"| ~"floorf64"| ~"ceilf32" | ~"ceilf64" |
-                ~"truncf32"| ~"truncf64" => 0,
+                "sqrtf32" | "sqrtf64" | "powif32" | "powif64" |
+                "sinf32"  | "sinf64"  | "cosf32"  | "cosf64"  |
+                "powf32"  | "powf64"  | "expf32"  | "expf64"  |
+                "exp2f32" | "exp2f64" | "logf32"  | "logf64"  |
+                "log10f32"| "log10f64"| "log2f32" | "log2f64" |
+                "fmaf32"  | "fmaf64"  | "fabsf32" | "fabsf64" |
+                "floorf32"| "floorf64"| "ceilf32" | "ceilf64" |
+                "truncf32"| "truncf64" => 0,
 
-                ~"ctpop8" | ~"ctpop16" | ~"ctpop32" | ~"ctpop64" => 0,
+                "ctpop8" | "ctpop16" | "ctpop32" | "ctpop64" => 0,
 
-                ~"ctlz8" | ~"ctlz16" | ~"ctlz32" | ~"ctlz64" => 0,
-                ~"cttz8" | ~"cttz16" | ~"cttz32" | ~"cttz64" => 0,
+                "ctlz8" | "ctlz16" | "ctlz32" | "ctlz64" => 0,
+                "cttz8" | "cttz16" | "cttz32" | "cttz64" => 0,
 
-                ~"bswap16" | ~"bswap32" | ~"bswap64" => 0,
+                "bswap16" | "bswap32" | "bswap64" => 0,
 
                 // would be cool to make these an enum instead of strings!
                 _ => fail!("unknown intrinsic in type_use")
diff --git a/src/librustc/middle/trans/write_guard.rs b/src/librustc/middle/trans/write_guard.rs
index ffcef3ae78c..d76d4642801 100644
--- a/src/librustc/middle/trans/write_guard.rs
+++ b/src/librustc/middle/trans/write_guard.rs
@@ -117,8 +117,8 @@ fn root(datum: &Datum,
     if bcx.sess().trace() {
         trans_trace(
             bcx, None,
-            @fmt!("preserving until end of scope %d",
-                  root_info.scope));
+            (fmt!("preserving until end of scope %d",
+                  root_info.scope)).to_managed());
     }
 
     // First, root the datum. Note that we must zero this value,
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index df3bc753ae1..a9ecd12bf2d 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -281,7 +281,7 @@ struct ctxt_ {
     tcache: type_cache,
     rcache: creader_cache,
     ccache: constness_cache,
-    short_names_cache: @mut HashMap<t, @~str>,
+    short_names_cache: @mut HashMap<t, @str>,
     needs_unwind_cleanup_cache: @mut HashMap<t, bool>,
     tc_cache: @mut HashMap<uint, TypeContents>,
     ast_ty_to_ty_cache: @mut HashMap<node_id, ast_ty_to_ty_cache_entry>,
@@ -3366,7 +3366,7 @@ pub fn field_idx_strict(tcx: ty::ctxt, id: ast::ident, fields: &[field])
     for fields.each |f| { if f.ident == id { return i; } i += 1u; }
     tcx.sess.bug(fmt!(
         "No field named `%s` found in the list of fields `%?`",
-        *tcx.sess.str_of(id),
+        tcx.sess.str_of(id),
         fields.map(|f| tcx.sess.str_of(f.ident))));
 }
 
@@ -3514,8 +3514,8 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
         terr_record_fields(values) => {
             fmt!("expected a record with field `%s` but found one with field \
                   `%s`",
-                 *cx.sess.str_of(values.expected),
-                 *cx.sess.str_of(values.found))
+                 cx.sess.str_of(values.expected),
+                 cx.sess.str_of(values.found))
         }
         terr_arg_count => ~"incorrect number of function parameters",
         terr_regions_does_not_outlive(*) => {
@@ -3549,7 +3549,7 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
                  trait_store_to_str(cx, (*values).found))
         }
         terr_in_field(err, fname) => {
-            fmt!("in field `%s`, %s", *cx.sess.str_of(fname),
+            fmt!("in field `%s`, %s", cx.sess.str_of(fname),
                  type_err_to_str(cx, err))
         }
         terr_sorts(values) => {
diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index bf4f30fb02e..4a546ce20d2 100644
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -297,7 +297,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
                 tcx.sess.span_err(span,
                                   fmt!("struct `%s` does not have a field
                                         named `%s`", name,
-                                       *tcx.sess.str_of(field.ident)));
+                                       tcx.sess.str_of(field.ident)));
             }
         }
     }
@@ -310,7 +310,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
             }
             tcx.sess.span_err(span,
                               fmt!("pattern does not mention field `%s`",
-                                   *tcx.sess.str_of(field.ident)));
+                                   tcx.sess.str_of(field.ident)));
         }
     }
 }
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 18bc30c7fb3..14f251878a4 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -490,7 +490,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
                   if pat_util::pat_is_binding(fcx.ccx.tcx.def_map, p) => {
                 assign(p.id, None);
                 debug!("Pattern binding %s is assigned to %s",
-                       *tcx.sess.str_of(path.idents[0]),
+                       tcx.sess.str_of(path.idents[0]),
                        fcx.infcx().ty_to_str(
                            fcx.inh.locals.get_copy(&p.id)));
               }
@@ -557,7 +557,7 @@ pub fn check_no_duplicate_fields(tcx: ty::ctxt,
         match orig_sp {
             Some(orig_sp) => {
                 tcx.sess.span_err(sp, fmt!("Duplicate field name %s in record type declaration",
-                                           *tcx.sess.str_of(id)));
+                                           tcx.sess.str_of(id)));
                 tcx.sess.span_note(orig_sp, "First declaration of this field occurred here");
                 break;
             }
@@ -599,7 +599,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
       ast::item_impl(_, _, _, ref ms) => {
         let rp = ccx.tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
         debug!("item_impl %s with id %d rp %?",
-               *ccx.tcx.sess.str_of(it.ident), it.id, rp);
+               ccx.tcx.sess.str_of(it.ident), it.id, rp);
         for ms.each |m| {
             check_method(ccx, *m);
         }
@@ -1396,7 +1396,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                       fmt!("type `%s` does not implement any method in scope \
                             named `%s`",
                            actual,
-                           *fcx.ccx.tcx.sess.str_of(method_name))
+                           fcx.ccx.tcx.sess.str_of(method_name))
                   },
                   expr_t,
                   None);
@@ -1772,7 +1772,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                     |actual| {
                         fmt!("attempted to take value of method `%s` on type `%s` \
                               (try writing an anonymous function)",
-                             *tcx.sess.str_of(field), actual)
+                             tcx.sess.str_of(field), actual)
                     },
                     expr_t, None);
             }
@@ -1783,7 +1783,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                     |actual| {
                         fmt!("attempted access of field `%s` on type `%s`, \
                               but no field with that name was found",
-                             *tcx.sess.str_of(field), actual)
+                             tcx.sess.str_of(field), actual)
                     },
                     expr_t, None);
             }
@@ -1821,14 +1821,14 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                     tcx.sess.span_err(
                         field.span,
                         fmt!("structure has no field named `%s`",
-                             *tcx.sess.str_of(field.node.ident)));
+                             tcx.sess.str_of(field.node.ident)));
                     error_happened = true;
                 }
                 Some((_, true)) => {
                     tcx.sess.span_err(
                         field.span,
                         fmt!("field `%s` specified more than once",
-                             *tcx.sess.str_of(field.node.ident)));
+                             tcx.sess.str_of(field.node.ident)));
                     error_happened = true;
                 }
                 Some((field_id, false)) => {
@@ -1862,7 +1862,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                     let (_, seen) = *class_field_map.get(&name);
                     if !seen {
                         missing_fields.push(
-                            ~"`" + *tcx.sess.str_of(name) + "`");
+                            ~"`" + tcx.sess.str_of(name) + "`");
                     }
                 }
 
@@ -3424,7 +3424,7 @@ pub fn check_bounds_are_used(ccx: @mut CrateCtxt,
         if !*b {
             ccx.tcx.sess.span_err(
                 span, fmt!("type parameter `%s` is unused",
-                           *ccx.tcx.sess.str_of(tps.get(i).ident)));
+                           ccx.tcx.sess.str_of(tps.get(i).ident)));
         }
     }
 }
@@ -3435,14 +3435,15 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
     }
 
     let tcx = ccx.tcx;
-    let (n_tps, inputs, output) = match *ccx.tcx.sess.str_of(it.ident) {
-        ~"size_of" |
-        ~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()),
-        ~"init" => (1u, ~[], param(ccx, 0u)),
-        ~"uninit" => (1u, ~[], param(ccx, 0u)),
-        ~"forget" => (1u, ~[ param(ccx, 0) ], ty::mk_nil()),
-        ~"transmute" => (2, ~[ param(ccx, 0) ], param(ccx, 1)),
-        ~"move_val" | ~"move_val_init" => {
+    let str = ccx.tcx.sess.str_of(it.ident);
+    let (n_tps, inputs, output) = match str.as_slice() {
+        "size_of" |
+        "pref_align_of" | "min_align_of" => (1u, ~[], ty::mk_uint()),
+        "init" => (1u, ~[], param(ccx, 0u)),
+        "uninit" => (1u, ~[], param(ccx, 0u)),
+        "forget" => (1u, ~[ param(ccx, 0) ], ty::mk_nil()),
+        "transmute" => (2, ~[ param(ccx, 0) ], param(ccx, 1)),
+        "move_val" | "move_val_init" => {
             (1u,
              ~[
                 ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), param(ccx, 0)),
@@ -3450,9 +3451,9 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
               ],
            ty::mk_nil())
         }
-        ~"needs_drop" => (1u, ~[], ty::mk_bool()),
+        "needs_drop" => (1u, ~[], ty::mk_bool()),
 
-        ~"atomic_cxchg"    | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => {
+        "atomic_cxchg"    | "atomic_cxchg_acq"| "atomic_cxchg_rel" => {
           (0,
            ~[
               ty::mk_mut_rptr(tcx,
@@ -3463,14 +3464,14 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_int())
         }
-        ~"atomic_load"     | ~"atomic_load_acq" => {
+        "atomic_load"     | "atomic_load_acq" => {
           (0,
            ~[
               ty::mk_imm_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int())
            ],
           ty::mk_int())
         }
-        ~"atomic_store"    | ~"atomic_store_rel" => {
+        "atomic_store"    | "atomic_store_rel" => {
           (0,
            ~[
               ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
@@ -3478,9 +3479,9 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"atomic_xchg"     | ~"atomic_xadd"     | ~"atomic_xsub"     |
-        ~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
-        ~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
+        "atomic_xchg"     | "atomic_xadd"     | "atomic_xsub"     |
+        "atomic_xchg_acq" | "atomic_xadd_acq" | "atomic_xsub_acq" |
+        "atomic_xchg_rel" | "atomic_xadd_rel" | "atomic_xsub_rel" => {
           (0,
            ~[
               ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
@@ -3489,11 +3490,11 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ty::mk_int())
         }
 
-        ~"get_tydesc" => {
+        "get_tydesc" => {
           // FIXME (#3730): return *intrinsic::tydesc, not *()
           (1u, ~[], ty::mk_nil_ptr(ccx.tcx))
         }
-        ~"visit_tydesc" => {
+        "visit_tydesc" => {
           let tydesc_name = special_idents::tydesc;
           assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
           let (_, tydesc_ty) = tcx.intrinsic_defs.get_copy(&tydesc_name);
@@ -3504,7 +3505,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
           });
           (0, ~[ td_ptr, visitor_object_ty ], ty::mk_nil())
         }
-        ~"frame_address" => {
+        "frame_address" => {
           let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
               purity: ast::impure_fn,
               sigil: ast::BorrowedSigil,
@@ -3519,10 +3520,10 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
           });
           (0u, ~[fty], ty::mk_nil())
         }
-        ~"morestack_addr" => {
+        "morestack_addr" => {
           (0u, ~[], ty::mk_nil_ptr(ccx.tcx))
         }
-        ~"memcpy32" => {
+        "memcpy32" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3537,7 +3538,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"memcpy64" => {
+        "memcpy64" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3552,7 +3553,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"memmove32" => {
+        "memmove32" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3567,7 +3568,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"memmove64" => {
+        "memmove64" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3582,7 +3583,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"memset32" => {
+        "memset32" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3594,7 +3595,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"memset64" => {
+        "memset64" => {
           (1,
            ~[
               ty::mk_ptr(tcx, ty::mt {
@@ -3606,75 +3607,75 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
            ],
            ty::mk_nil())
         }
-        ~"sqrtf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"sqrtf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"powif32" => {
+        "sqrtf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "sqrtf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "powif32" => {
            (0,
             ~[ ty::mk_f32(), ty::mk_i32() ],
             ty::mk_f32())
         }
-        ~"powif64" => {
+        "powif64" => {
            (0,
             ~[ ty::mk_f64(), ty::mk_i32() ],
             ty::mk_f64())
         }
-        ~"sinf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"sinf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"cosf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"cosf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"powf32" => {
+        "sinf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "sinf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "cosf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "cosf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "powf32" => {
            (0,
             ~[ ty::mk_f32(), ty::mk_f32() ],
             ty::mk_f32())
         }
-        ~"powf64" => {
+        "powf64" => {
            (0,
             ~[ ty::mk_f64(), ty::mk_f64() ],
             ty::mk_f64())
         }
-        ~"expf32"   => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"expf64"   => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"exp2f32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"exp2f64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"logf32"   => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"logf64"   => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"log10f32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"log10f64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"log2f32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"log2f64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"fmaf32" => {
+        "expf32"   => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "expf64"   => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "exp2f32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "exp2f64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "logf32"   => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "logf64"   => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "log10f32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "log10f64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "log2f32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "log2f64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "fmaf32" => {
             (0,
              ~[ ty::mk_f32(), ty::mk_f32(), ty::mk_f32() ],
              ty::mk_f32())
         }
-        ~"fmaf64" => {
+        "fmaf64" => {
             (0,
              ~[ ty::mk_f64(), ty::mk_f64(), ty::mk_f64() ],
              ty::mk_f64())
         }
-        ~"fabsf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"fabsf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"floorf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"floorf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"ceilf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"ceilf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"truncf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-        ~"truncf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-        ~"ctpop8"   => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-        ~"ctpop16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-        ~"ctpop32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-        ~"ctpop64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-        ~"ctlz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-        ~"ctlz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-        ~"ctlz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-        ~"ctlz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-        ~"cttz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-        ~"cttz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-        ~"cttz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-        ~"cttz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-        ~"bswap16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-        ~"bswap32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-        ~"bswap64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+        "fabsf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "fabsf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "floorf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "floorf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "ceilf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "ceilf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "truncf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+        "truncf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+        "ctpop8"   => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+        "ctpop16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+        "ctpop32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+        "ctpop64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+        "ctlz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+        "ctlz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+        "ctlz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+        "ctlz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+        "cttz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+        "cttz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+        "cttz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+        "cttz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+        "bswap16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+        "bswap32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+        "bswap64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
         ref other => {
             tcx.sess.span_err(it.span,
                               fmt!("unrecognized intrinsic function: `%s`",
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 3de51629741..115381a76cf 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -251,7 +251,7 @@ impl CoherenceChecker {
         if associated_traits.len() == 0 {
             debug!("(checking implementation) no associated traits for item \
                     '%s'",
-                   *self.crate_context.tcx.sess.str_of(item.ident));
+                   self.crate_context.tcx.sess.str_of(item.ident));
 
             match get_base_type_def_id(self.inference_context,
                                        item.span,
@@ -278,7 +278,7 @@ impl CoherenceChecker {
                     associated_trait.ref_id);
             debug!("(checking implementation) adding impl for trait '%s', item '%s'",
                    trait_ref.repr(self.crate_context.tcx),
-                   *self.crate_context.tcx.sess.str_of(item.ident));
+                   self.crate_context.tcx.sess.str_of(item.ident));
 
             self.instantiate_default_methods(item.id, trait_ref);
 
@@ -401,7 +401,7 @@ impl CoherenceChecker {
                     // method to that entry.
                     debug!("(checking implementation) adding method `%s` \
                             to entry for existing trait",
-                            *self.crate_context.tcx.sess.str_of(
+                            self.crate_context.tcx.sess.str_of(
                                 provided_method_info.method_info.ident));
                     mis.push(provided_method_info);
                 }
@@ -409,7 +409,7 @@ impl CoherenceChecker {
                     // If the trait doesn't have an entry yet, create one.
                     debug!("(checking implementation) creating new entry \
                             for method `%s`",
-                            *self.crate_context.tcx.sess.str_of(
+                            self.crate_context.tcx.sess.str_of(
                                 provided_method_info.method_info.ident));
                     pmm.insert(local_def(impl_id),
                                @mut ~[provided_method_info]);
@@ -742,7 +742,7 @@ impl CoherenceChecker {
 
             tcx.sess.span_err(trait_ref_span,
                               fmt!("missing method `%s`",
-                                   *tcx.sess.str_of(method.ident)));
+                                   tcx.sess.str_of(method.ident)));
         }
     }
 
@@ -794,7 +794,7 @@ impl CoherenceChecker {
             for all_provided_methods.each |provided_method| {
                 debug!(
                     "(creating impl) adding provided method `%s` to impl",
-                    *sess.str_of(provided_method.method_info.ident));
+                    sess.str_of(provided_method.method_info.ident));
                 vec::push(all_methods, provided_method.method_info);
             }
         }
@@ -909,7 +909,7 @@ impl CoherenceChecker {
                         session.bug(fmt!(
                             "no base type for external impl \
                              with no trait: %s (type %s)!",
-                             *session.str_of(implementation.ident),
+                             session.str_of(implementation.ident),
                              ty_to_str(self.crate_context.tcx,self_type.ty)));
                     }
                     Some(_) => {
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index 1a3b284556b..6ced82df1d7 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -471,7 +471,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
                 cm.span,
                 fmt!("method `%s` has a `%s` declaration in the impl, \
                       but not in the trait",
-                     *tcx.sess.str_of(trait_m.ident),
+                     tcx.sess.str_of(trait_m.ident),
                      explicit_self_to_str(impl_m.explicit_self, tcx.sess.intr())));
             return;
         }
@@ -480,7 +480,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
                 cm.span,
                 fmt!("method `%s` has a `%s` declaration in the trait, \
                       but not in the impl",
-                     *tcx.sess.str_of(trait_m.ident),
+                     tcx.sess.str_of(trait_m.ident),
                      explicit_self_to_str(trait_m.explicit_self, tcx.sess.intr())));
             return;
         }
@@ -496,7 +496,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
             cm.span,
             fmt!("method `%s` has %u type %s, but its trait \
                   declaration has %u type %s",
-                 *tcx.sess.str_of(trait_m.ident),
+                 tcx.sess.str_of(trait_m.ident),
                  num_impl_m_type_params,
                  pluralize(num_impl_m_type_params, ~"parameter"),
                  num_trait_m_type_params,
@@ -509,7 +509,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
             cm.span,
             fmt!("method `%s` has %u parameter%s \
                   but the trait has %u",
-                 *tcx.sess.str_of(trait_m.ident),
+                 tcx.sess.str_of(trait_m.ident),
                  impl_m.fty.sig.inputs.len(),
                  if impl_m.fty.sig.inputs.len() == 1 { "" } else { "s" },
                  trait_m.fty.sig.inputs.len()));
@@ -533,7 +533,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
                      which is not required by \
                      the corresponding type parameter \
                      in the trait declaration",
-                    *tcx.sess.str_of(trait_m.ident),
+                    tcx.sess.str_of(trait_m.ident),
                     i,
                     extra_bounds.user_string(tcx)));
            return;
@@ -551,7 +551,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
                       type parameter %u has %u trait %s, but the \
                       corresponding type parameter in \
                       the trait declaration has %u trait %s",
-                     *tcx.sess.str_of(trait_m.ident),
+                     tcx.sess.str_of(trait_m.ident),
                      i, impl_param_def.bounds.trait_bounds.len(),
                      pluralize(impl_param_def.bounds.trait_bounds.len(),
                                ~"bound"),
@@ -652,7 +652,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
             tcx.sess.span_err(
                 cm.span,
                 fmt!("method `%s` has an incompatible type: %s",
-                     *tcx.sess.str_of(trait_m.ident),
+                     tcx.sess.str_of(trait_m.ident),
                      ty::type_err_to_str(tcx, terr)));
             ty::note_and_explain_type_err(tcx, terr);
         }
@@ -700,7 +700,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt,
                 tcx.sess.span_err(
                     impl_m.span,
                     fmt!("method `%s` is not a member of trait `%s`",
-                         *tcx.sess.str_of(impl_m.mty.ident),
+                         tcx.sess.str_of(impl_m.mty.ident),
                          path_to_str(a_trait_ty.path, tcx.sess.intr())));
             }
         }
@@ -829,7 +829,7 @@ pub fn convert(ccx: &CrateCtxt, it: @ast::item) {
     let tcx = ccx.tcx;
     let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
     debug!("convert: item %s with id %d rp %?",
-           *tcx.sess.str_of(it.ident), it.id, rp);
+           tcx.sess.str_of(it.ident), it.id, rp);
     match it.node {
       // These don't define types.
       ast::item_foreign_mod(_) | ast::item_mod(_) => {}
@@ -1084,7 +1084,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item)
             ty: ty::mk_bare_fn(ccx.tcx, tofd)
         };
         debug!("type of %s (id %d) is %s",
-               *tcx.sess.str_of(it.ident),
+               tcx.sess.str_of(it.ident),
                it.id,
                ppaux::ty_to_str(tcx, tpt.ty));
         ccx.tcx.tcache.insert(local_def(it.id), tpt);
diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc
index ff19893daad..7d86b312908 100644
--- a/src/librustc/rustc.rc
+++ b/src/librustc/rustc.rc
@@ -236,9 +236,9 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
     ::core::logging::console_off();
 
     let mut args = /*bad*/copy *args;
-    let binary = @args.shift();
+    let binary = args.shift().to_managed();
 
-    if args.is_empty() { usage(*binary); return; }
+    if args.is_empty() { usage(binary); return; }
 
     let matches =
         &match getopts::groups::getopts(args, optgroups()) {
@@ -249,7 +249,7 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
         };
 
     if opt_present(matches, "h") || opt_present(matches, "help") {
-        usage(*binary);
+        usage(binary);
         return;
     }
 
@@ -276,16 +276,16 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
     }
 
     if opt_present(matches, "v") || opt_present(matches, "version") {
-        version(*binary);
+        version(binary);
         return;
     }
     let input = match matches.free.len() {
       0u => early_error(demitter, ~"no input filename given"),
       1u => {
-        let ifile = /*bad*/copy matches.free[0];
-        if ifile == ~"-" {
+        let ifile = matches.free[0].as_slice();
+        if "-" == ifile {
             let src = str::from_bytes(io::stdin().read_whole_stream());
-            str_input(src)
+            str_input(src.to_managed())
         } else {
             file_input(Path(ifile))
         }
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 59f44c3c1f9..4979f5acf63 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -159,7 +159,7 @@ pub fn bound_region_to_str_space(cx: ctxt,
     if cx.sess.verbose() { return fmt!("%s%? ", prefix, br); }
 
     match br {
-      br_named(id)         => fmt!("%s'%s ", prefix, *cx.sess.str_of(id)),
+      br_named(id)         => fmt!("%s'%s ", prefix, cx.sess.str_of(id)),
       br_self              => fmt!("%s'self ", prefix),
       br_anon(_)           => prefix.to_str(),
       br_fresh(_)          => prefix.to_str(),
@@ -323,7 +323,7 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
         match ident {
           Some(i) => {
               s.push_char(' ');
-              s.push_str(*cx.sess.str_of(i));
+              s.push_str(cx.sess.str_of(i));
           }
           _ => { }
         }
@@ -389,7 +389,7 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                        &m.fty.sig) + ";"
     }
     fn field_to_str(cx: ctxt, f: field) -> ~str {
-        return *cx.sess.str_of(f.ident) + ": " + mt_to_str(cx, &f.mt);
+        return fmt!("%s: %s", cx.sess.str_of(f.ident), mt_to_str(cx, &f.mt));
     }
 
     // if there is an id, print that instead of the structural type:
@@ -656,7 +656,7 @@ impl Repr for ty::Method {
 
 impl Repr for ast::ident {
     fn repr(&self, _tcx: ctxt) -> ~str {
-        copy *token::ident_to_str(self)
+        token::ident_to_str(self).to_owned()
     }
 }
 
diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs
index 74a403ff741..9d8f750a350 100644
--- a/src/librustdoc/astsrv.rs
+++ b/src/librustdoc/astsrv.rs
@@ -41,7 +41,7 @@ pub struct Ctxt {
 
 type SrvOwner<'self,T> = &'self fn(srv: Srv) -> T;
 pub type CtxtHandler<T> = ~fn(ctxt: Ctxt) -> T;
-type Parser = ~fn(Session, s: ~str) -> @ast::crate;
+type Parser = ~fn(Session, s: @str) -> @ast::crate;
 
 enum Msg {
     HandleRequest(~fn(Ctxt)),
@@ -68,7 +68,7 @@ fn run<T>(owner: SrvOwner<T>, source: ~str, parse: Parser) -> T {
     let source = Cell::new(source);
     let parse = Cell::new(parse);
     do task::spawn {
-        act(&po, source.take(), parse.take());
+        act(&po, source.take().to_managed(), parse.take());
     }
 
     let srv_ = Srv {
@@ -80,12 +80,12 @@ fn run<T>(owner: SrvOwner<T>, source: ~str, parse: Parser) -> T {
     res
 }
 
-fn act(po: &Port<Msg>, source: ~str, parse: Parser) {
+fn act(po: &Port<Msg>, source: @str, parse: Parser) {
     let sess = build_session();
 
     let ctxt = build_ctxt(
         sess,
-        parse(sess, copy source)
+        parse(sess, source)
     );
 
     let mut keep_going = true;
diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs
index 026f57df035..defa0da85b6 100644
--- a/src/librustdoc/attr_parser.rs
+++ b/src/librustdoc/attr_parser.rs
@@ -41,13 +41,13 @@ pub fn parse_crate(attrs: ~[ast::attribute]) -> CrateAttrs {
     let name = attr::last_meta_item_value_str_by_name(link_metas, "name");
 
     CrateAttrs {
-        name: name.map(|s| copy **s)
+        name: name.map(|s| s.to_owned())
     }
 }
 
 pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
     let doc_strs = do doc_metas(attrs).filter_mapped |meta| {
-        attr::get_meta_item_value_str(*meta).map(|s| copy **s)
+        attr::get_meta_item_value_str(*meta).map(|s| s.to_owned())
     };
     if doc_strs.is_empty() {
         None
diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs
index 73956df9542..bbc1ddcdbda 100644
--- a/src/librustdoc/extract.rs
+++ b/src/librustdoc/extract.rs
@@ -25,7 +25,7 @@ use syntax::parse::token;
 // thread-local data
 // Hack-Becomes-Feature: using thread-local-state everywhere...
 pub fn to_str(id: ast::ident) -> ~str {
-    return copy *ident_to_str(&id);
+    /* bad */ ident_to_str(&id).to_owned()
 }
 
 // get rid of this pointless function:
diff --git a/src/librustdoc/parse.rs b/src/librustdoc/parse.rs
index 455720f47ef..138e4d49156 100644
--- a/src/librustdoc/parse.rs
+++ b/src/librustdoc/parse.rs
@@ -23,9 +23,9 @@ pub fn from_file(file: &Path) -> @ast::crate {
         file, ~[], parse::new_parse_sess(None))
 }
 
-pub fn from_str(source: ~str) -> @ast::crate {
+pub fn from_str(source: @str) -> @ast::crate {
     parse::parse_crate_from_source_str(
-        ~"-", @source, ~[], parse::new_parse_sess(None))
+        @"-", source, ~[], parse::new_parse_sess(None))
 }
 
 pub fn from_file_sess(sess: session::Session, file: &Path) -> @ast::crate {
@@ -33,11 +33,11 @@ pub fn from_file_sess(sess: session::Session, file: &Path) -> @ast::crate {
         file, cfg(sess, file_input(copy *file)), sess.parse_sess)
 }
 
-pub fn from_str_sess(sess: session::Session, source: ~str) -> @ast::crate {
+pub fn from_str_sess(sess: session::Session, source: @str) -> @ast::crate {
     parse::parse_crate_from_source_str(
-        ~"-", @copy source, cfg(sess, str_input(source)), sess.parse_sess)
+        @"-", source, cfg(sess, str_input(source)), sess.parse_sess)
 }
 
 fn cfg(sess: session::Session, input: driver::input) -> ast::crate_cfg {
-    driver::build_configuration(sess, @~"rustdoc", &input)
+    driver::build_configuration(sess, @"rustdoc", &input)
 }
diff --git a/src/librusti/rusti.rc b/src/librusti/rusti.rc
index 3e1883062f3..8df1018a0de 100644
--- a/src/librusti/rusti.rc
+++ b/src/librusti/rusti.rc
@@ -117,7 +117,7 @@ fn record(mut repl: Repl, blk: &ast::blk, intr: @token::ident_interner) -> Repl
 
 /// Run an input string in a Repl, returning the new Repl.
 fn run(repl: Repl, input: ~str) -> Repl {
-    let binary = @copy repl.binary;
+    let binary = repl.binary.to_managed();
     let options = @session::options {
         crate_type: session::unknown_crate,
         binary: binary,
@@ -130,7 +130,7 @@ fn run(repl: Repl, input: ~str) -> Repl {
     let head = include_str!("wrapper.rs").to_owned();
     let foot = fmt!("fn main() {\n%s\n%s\n\nprint({\n%s\n})\n}",
                     repl.view_items, repl.stmts, input);
-    let wrapped = driver::str_input(head + foot);
+    let wrapped = driver::str_input((head + foot).to_managed());
 
     debug!("inputting %s", head + foot);
 
@@ -186,7 +186,7 @@ fn run(repl: Repl, input: ~str) -> Repl {
 fn compile_crate(src_filename: ~str, binary: ~str) -> Option<bool> {
     match do task::try {
         let src_path = Path(src_filename);
-        let binary = @copy binary;
+        let binary = binary.to_managed();
         let options = @session::options {
             binary: binary,
             addl_lib_search_paths: @mut ~[os::getcwd()],
diff --git a/src/librustpkg/rustpkg.rc b/src/librustpkg/rustpkg.rc
index 387fa0d51d7..f9dc9a6160f 100644
--- a/src/librustpkg/rustpkg.rc
+++ b/src/librustpkg/rustpkg.rc
@@ -100,7 +100,7 @@ impl<'self> PkgScript<'self> {
     /// a PkgScript that we can then execute
     fn parse<'a>(script: Path, workspace: &Path, id: &'a PkgId) -> PkgScript<'a> {
         // Get the executable name that was invoked
-        let binary = @copy os::args()[0];
+        let binary = os::args()[0].to_managed();
         // Build the rustc session data structures to pass
         // to the compiler
         let options = @session::options {
@@ -145,7 +145,7 @@ impl<'self> PkgScript<'self> {
                 let root = r.pop().pop().pop().pop(); // :-\
                 debug!("Root is %s, calling compile_rest", root.to_str());
                 let exe = self.build_dir.push(~"pkg" + util::exe_suffix());
-                let binary = @copy os::args()[0];
+                let binary = os::args()[0].to_managed();
                 util::compile_crate_from_input(&self.input,
                                                &self.build_dir,
                                                sess,
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
index 75e2c3fd464..1b863cd9a86 100644
--- a/src/librustpkg/util.rs
+++ b/src/librustpkg/util.rs
@@ -80,7 +80,7 @@ fn fold_mod(_ctx: @mut ReadyCtx,
     fn strip_main(item: @ast::item) -> @ast::item {
         @ast::item {
             attrs: do item.attrs.filtered |attr| {
-                *attr::get_attr_name(attr) != ~"main"
+                "main" != attr::get_attr_name(attr)
             },
             .. copy *item
         }
@@ -109,7 +109,7 @@ fn fold_item(ctx: @mut ReadyCtx,
                 ast::meta_list(_, ref mis) => {
                     for mis.each |mi| {
                         match mi.node {
-                            ast::meta_word(cmd) => cmds.push(copy *cmd),
+                            ast::meta_word(cmd) => cmds.push(cmd.to_owned()),
                             _ => {}
                         };
                     }
@@ -205,7 +205,7 @@ pub fn compile_input(ctxt: &Ctx,
     // tjc: by default, use the package ID name as the link name
     // not sure if we should support anything else
 
-    let binary = @(copy os::args()[0]);
+    let binary = os::args()[0].to_managed();
 
     debug!("flags: %s", flags.connect(" "));
     debug!("cfgs: %s", cfgs.connect(" "));
@@ -270,11 +270,11 @@ pub fn compile_input(ctxt: &Ctx,
         debug!("Injecting link name: %s", short_name_to_use);
         crate = @codemap::respan(crate.span, ast::crate_ {
             attrs: ~[mk_attr(@dummy_spanned(
-                meta_list(@~"link",
-                 ~[@dummy_spanned(meta_name_value(@~"name",
-                                      mk_string_lit(@short_name_to_use))),
-                   @dummy_spanned(meta_name_value(@~"vers",
-                         mk_string_lit(@pkg_id.version.to_str_nonempty())))])))],
+                meta_list(@"link",
+                 ~[@dummy_spanned(meta_name_value(@"name",
+                                      mk_string_lit(short_name_to_use.to_managed()))),
+                   @dummy_spanned(meta_name_value(@"vers",
+                         mk_string_lit(pkg_id.version.to_str_nonempty().to_managed())))])))],
             ..copy crate.node});
     }
 
@@ -363,24 +363,24 @@ fn find_and_install_dependencies(ctxt: &Ctx,
                     None => ()
                 };
                 let lib_name = sess.str_of(lib_ident);
-                match find_library_in_search_path(my_ctxt.sysroot_opt, *lib_name) {
+                match find_library_in_search_path(my_ctxt.sysroot_opt, lib_name) {
                     Some(installed_path) => {
                         debug!("It exists: %s", installed_path.to_str());
                     }
                     None => {
                         // Try to install it
-                        let pkg_id = PkgId::new(*lib_name);
+                        let pkg_id = PkgId::new(lib_name);
                         my_ctxt.install(&my_workspace, &pkg_id);
                         let built_lib =
                             built_library_in_workspace(&pkg_id,
                                 &my_workspace).expect(fmt!("find_and_install_dependencies: \
                                 I thought I already built %s, but the library doesn't seem \
-                                to exist", *lib_name));
+                                to exist", lib_name));
                         // Also, add an additional search path
                         let installed_path = target_library_in_workspace(&my_workspace,
                                                                          &built_lib).pop();
                         debug!("Great, I installed %s, and it's in %s",
-                               *lib_name, installed_path.to_str());
+                               lib_name, installed_path.to_str());
                         save(installed_path);
                     }
                 }
@@ -415,7 +415,7 @@ pub fn link_exe(src: &Path, dest: &Path) -> bool {
     }
 }
 
-pub fn mk_string_lit(s: @~str) -> ast::lit {
+pub fn mk_string_lit(s: @str) -> ast::lit {
     spanned {
         node: ast::lit_str(s),
         span: dummy_sp()
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index f27ae3b828c..e3182916723 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -84,7 +84,7 @@ pub type Mrk = uint;
 
 impl<S:Encoder> Encodable<S> for ident {
     fn encode(&self, s: &mut S) {
-        s.emit_str(*interner_get(self.name));
+        s.emit_str(interner_get(self.name));
     }
 }
 
@@ -228,9 +228,9 @@ pub type meta_item = spanned<meta_item_>;
 
 #[deriving(Eq, Encodable, Decodable)]
 pub enum meta_item_ {
-    meta_word(@~str),
-    meta_list(@~str, ~[@meta_item]),
-    meta_name_value(@~str, lit),
+    meta_word(@str),
+    meta_list(@str, ~[@meta_item]),
+    meta_name_value(@str, lit),
 }
 
 pub type blk = spanned<blk_>;
@@ -634,12 +634,12 @@ pub type lit = spanned<lit_>;
 
 #[deriving(Eq, Encodable, Decodable)]
 pub enum lit_ {
-    lit_str(@~str),
+    lit_str(@str),
     lit_int(i64, int_ty),
     lit_uint(u64, uint_ty),
     lit_int_unsuffixed(i64),
-    lit_float(@~str, float_ty),
-    lit_float_unsuffixed(@~str),
+    lit_float(@str, float_ty),
+    lit_float_unsuffixed(@str),
     lit_nil,
     lit_bool(bool),
 }
@@ -819,10 +819,10 @@ pub enum asm_dialect {
 
 #[deriving(Eq, Encodable, Decodable)]
 pub struct inline_asm {
-    asm: @~str,
-    clobbers: @~str,
-    inputs: ~[(@~str, @expr)],
-    outputs: ~[(@~str, @expr)],
+    asm: @str,
+    clobbers: @str,
+    inputs: ~[(@str, @expr)],
+    outputs: ~[(@str, @expr)],
     volatile: bool,
     alignstack: bool,
     dialect: asm_dialect
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 430567e3e2f..ca91d3a4f8c 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -58,8 +58,8 @@ pub fn path_to_str_with_sep(p: &[path_elt], sep: &str, itr: @ident_interner)
                          -> ~str {
     let strs = do p.map |e| {
         match *e {
-          path_mod(s) => copy *itr.get(s.name),
-          path_name(s) => copy *itr.get(s.name)
+          path_mod(s) => itr.get(s.name),
+          path_name(s) => itr.get(s.name)
         }
     };
     strs.connect(sep)
@@ -68,9 +68,9 @@ pub fn path_to_str_with_sep(p: &[path_elt], sep: &str, itr: @ident_interner)
 pub fn path_ident_to_str(p: &path, i: ident, itr: @ident_interner) -> ~str {
     if p.is_empty() {
         //FIXME /* FIXME (#2543) */ copy *i
-        copy *itr.get(i.name)
+        itr.get(i.name).to_owned()
     } else {
-        fmt!("%s::%s", path_to_str(*p, itr), *itr.get(i.name))
+        fmt!("%s::%s", path_to_str(*p, itr), itr.get(i.name))
     }
 }
 
@@ -80,8 +80,8 @@ pub fn path_to_str(p: &[path_elt], itr: @ident_interner) -> ~str {
 
 pub fn path_elt_to_str(pe: path_elt, itr: @ident_interner) -> ~str {
     match pe {
-        path_mod(s) => copy *itr.get(s.name),
-        path_name(s) => copy *itr.get(s.name)
+        path_mod(s) => itr.get(s.name).to_owned(),
+        path_name(s) => itr.get(s.name).to_owned()
     }
 }
 
@@ -359,16 +359,16 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
       }
       Some(&node_method(m, _, path)) => {
         fmt!("method %s in %s (id=%?)",
-             *itr.get(m.ident.name), path_to_str(*path, itr), id)
+             itr.get(m.ident.name), path_to_str(*path, itr), id)
       }
       Some(&node_trait_method(ref tm, _, path)) => {
         let m = ast_util::trait_method_to_ty_method(&**tm);
         fmt!("method %s in %s (id=%?)",
-             *itr.get(m.ident.name), path_to_str(*path, itr), id)
+             itr.get(m.ident.name), path_to_str(*path, itr), id)
       }
       Some(&node_variant(ref variant, _, path)) => {
         fmt!("variant %s in %s (id=%?)",
-             *itr.get(variant.node.name.name), path_to_str(*path, itr), id)
+             itr.get(variant.node.name.name), path_to_str(*path, itr), id)
       }
       Some(&node_expr(expr)) => {
         fmt!("expr %s (id=%?)", pprust::expr_to_str(expr, itr), id)
@@ -384,7 +384,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
         fmt!("arg (id=%?)", id)
       }
       Some(&node_local(ident)) => {
-        fmt!("local (id=%?, name=%s)", id, *itr.get(ident.name))
+        fmt!("local (id=%?, name=%s)", id, itr.get(ident.name))
       }
       Some(&node_block(_)) => {
         fmt!("block")
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 904f35bce5a..d4aa9229319 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -28,7 +28,7 @@ use core::iterator::IteratorUtil;
 
 pub fn path_name_i(idents: &[ident]) -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
-    idents.map(|i| copy *token::interner_get(i.name)).connect("::")
+    idents.map(|i| token::interner_get(i.name)).connect("::")
 }
 
 pub fn path_to_ident(p: @Path) -> ident { copy *p.idents.last() }
@@ -815,7 +815,7 @@ mod test {
         assert_eq!(copy s,~[14]);
     }
 
-    // convert a list of uints to an @~[ident]
+    // convert a list of uints to an @[ident]
     // (ignores the interner completely)
     fn uints_to_idents (uints: &~[uint]) -> @~[ident] {
         @uints.map(|u|{ ident {name:*u, ctxt: empty_ctxt} })
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index da5874f7b05..1bf21c18886 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -26,23 +26,23 @@ use extra;
 
 /* Constructors */
 
-pub fn mk_name_value_item_str(name: @~str, value: @~str)
+pub fn mk_name_value_item_str(name: @str, value: @str)
                            -> @ast::meta_item {
     let value_lit = dummy_spanned(ast::lit_str(value));
     mk_name_value_item(name, value_lit)
 }
 
-pub fn mk_name_value_item(name: @~str, value: ast::lit)
+pub fn mk_name_value_item(name: @str, value: ast::lit)
         -> @ast::meta_item {
     @dummy_spanned(ast::meta_name_value(name, value))
 }
 
-pub fn mk_list_item(name: @~str, items: ~[@ast::meta_item]) ->
+pub fn mk_list_item(name: @str, items: ~[@ast::meta_item]) ->
    @ast::meta_item {
     @dummy_spanned(ast::meta_list(name, items))
 }
 
-pub fn mk_word_item(name: @~str) -> @ast::meta_item {
+pub fn mk_word_item(name: @str) -> @ast::meta_item {
     @dummy_spanned(ast::meta_word(name))
 }
 
@@ -52,13 +52,13 @@ pub fn mk_attr(item: @ast::meta_item) -> ast::attribute {
                                     is_sugared_doc: false })
 }
 
-pub fn mk_sugared_doc_attr(text: ~str,
+pub fn mk_sugared_doc_attr(text: @str,
                            lo: BytePos, hi: BytePos) -> ast::attribute {
     let style = doc_comment_style(text);
-    let lit = spanned(lo, hi, ast::lit_str(@text));
+    let lit = spanned(lo, hi, ast::lit_str(text));
     let attr = ast::attribute_ {
         style: style,
-        value: @spanned(lo, hi, ast::meta_name_value(@~"doc", lit)),
+        value: @spanned(lo, hi, ast::meta_name_value(@"doc", lit)),
         is_sugared_doc: true
     };
     spanned(lo, hi, attr)
@@ -78,8 +78,8 @@ pub fn attr_metas(attrs: &[ast::attribute]) -> ~[@ast::meta_item] {
 pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute {
     if attr.node.is_sugared_doc {
         let comment = get_meta_item_value_str(attr.node.value).get();
-        let meta = mk_name_value_item_str(@~"doc",
-                                     @strip_doc_comment_decoration(*comment));
+        let meta = mk_name_value_item_str(@"doc",
+                                     strip_doc_comment_decoration(comment).to_managed());
         mk_attr(meta)
     } else {
         *attr
@@ -88,11 +88,11 @@ pub fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute {
 
 /* Accessors */
 
-pub fn get_attr_name(attr: &ast::attribute) -> @~str {
+pub fn get_attr_name(attr: &ast::attribute) -> @str {
     get_meta_item_name(attr.node.value)
 }
 
-pub fn get_meta_item_name(meta: @ast::meta_item) -> @~str {
+pub fn get_meta_item_name(meta: @ast::meta_item) -> @str {
     match meta.node {
         ast::meta_word(n) => n,
         ast::meta_name_value(n, _) => n,
@@ -104,7 +104,7 @@ pub fn get_meta_item_name(meta: @ast::meta_item) -> @~str {
  * Gets the string value if the meta_item is a meta_name_value variant
  * containing a string, otherwise none
  */
-pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@~str> {
+pub fn get_meta_item_value_str(meta: @ast::meta_item) -> Option<@str> {
     match meta.node {
         ast::meta_name_value(_, v) => {
             match v.node {
@@ -130,7 +130,7 @@ pub fn get_meta_item_list(meta: @ast::meta_item)
  * a tuple containing the name and string value, otherwise `none`
  */
 pub fn get_name_value_str_pair(item: @ast::meta_item)
-                            -> Option<(@~str, @~str)> {
+                            -> Option<(@str, @str)> {
     match attr::get_meta_item_value_str(item) {
       Some(value) => {
         let name = attr::get_meta_item_name(item);
@@ -147,7 +147,7 @@ pub fn get_name_value_str_pair(item: @ast::meta_item)
 pub fn find_attrs_by_name(attrs: &[ast::attribute], name: &str) ->
    ~[ast::attribute] {
     do vec::filter_mapped(attrs) |a| {
-        if name == *get_attr_name(a) {
+        if name == get_attr_name(a) {
             Some(*a)
         } else {
             None
@@ -160,7 +160,7 @@ pub fn find_meta_items_by_name(metas: &[@ast::meta_item], name: &str) ->
    ~[@ast::meta_item] {
     let mut rs = ~[];
     for metas.each |mi| {
-        if name == *get_meta_item_name(*mi) {
+        if name == get_meta_item_name(*mi) {
             rs.push(*mi)
         }
     }
@@ -214,7 +214,7 @@ pub fn attrs_contains_name(attrs: &[ast::attribute], name: &str) -> bool {
 }
 
 pub fn first_attr_value_str_by_name(attrs: &[ast::attribute], name: &str)
-                                 -> Option<@~str> {
+                                 -> Option<@str> {
 
     let mattrs = find_attrs_by_name(attrs, name);
     if mattrs.len() > 0 {
@@ -232,7 +232,7 @@ fn last_meta_item_by_name(items: &[@ast::meta_item], name: &str)
 }
 
 pub fn last_meta_item_value_str_by_name(items: &[@ast::meta_item], name: &str)
-                                     -> Option<@~str> {
+                                     -> Option<@str> {
 
     match last_meta_item_by_name(items, name) {
         Some(item) => {
@@ -282,7 +282,7 @@ pub fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: &str) ->
    ~[@ast::meta_item] {
 
     return vec::filter_mapped(items, |item| {
-        if name != *get_meta_item_name(*item) {
+        if name != get_meta_item_name(*item) {
             Some(*item)
         } else {
             None
@@ -316,8 +316,8 @@ pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr {
     // FIXME (#2809)---validate the usage of #[inline] and #[inline(always)]
     do attrs.iter().fold(ia_none) |ia,attr| {
         match attr.node.value.node {
-          ast::meta_word(@~"inline") => ia_hint,
-          ast::meta_list(@~"inline", ref items) => {
+          ast::meta_word(s) if "inline" == s => ia_hint,
+          ast::meta_list(s, ref items) if "inline" == s => {
             if !find_meta_items_by_name(*items, "always").is_empty() {
                 ia_always
             } else if !find_meta_items_by_name(*items, "never").is_empty() {
@@ -341,7 +341,7 @@ pub fn require_unique_names(diagnostic: @span_handler,
         // FIXME: How do I silence the warnings? --pcw (#2619)
         if !set.insert(name) {
             diagnostic.span_fatal(meta.span,
-                                  fmt!("duplicate meta item `%s`", *name));
+                                  fmt!("duplicate meta item `%s`", name));
         }
     }
 }
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 68403b2c608..0c09a001d48 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -184,7 +184,7 @@ pub struct Loc {
 // Actually, *none* of the clients use the filename *or* file field;
 // perhaps they should just be removed.
 pub struct LocWithOpt {
-    filename: ~str,
+    filename: FileName,
     line: uint,
     col: CharPos,
     file: Option<@FileMap>,
@@ -193,7 +193,7 @@ pub struct LocWithOpt {
 // used to be structural records. Better names, anyone?
 pub struct FileMapAndLine {fm: @FileMap, line: uint}
 pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos}
-pub struct NameAndSpan {name: ~str, span: Option<span>}
+pub struct NameAndSpan {name: @str, span: Option<span>}
 
 impl to_bytes::IterBytes for NameAndSpan {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
@@ -227,7 +227,7 @@ impl to_bytes::IterBytes for ExpnInfo {
     }
 }
 
-pub type FileName = ~str;
+pub type FileName = @str;
 
 pub struct FileLines
 {
@@ -261,7 +261,7 @@ pub struct FileMap {
     /// Extra information used by qquote
     substr: FileSubstr,
     /// The complete source code
-    src: @~str,
+    src: @str,
     /// The start position of this source in the CodeMap
     start_pos: BytePos,
     /// Locations of lines beginnings in the source code
@@ -316,14 +316,14 @@ impl CodeMap {
     }
 
     /// Add a new FileMap to the CodeMap and return it
-    pub fn new_filemap(&self, filename: FileName, src: @~str) -> @FileMap {
+    pub fn new_filemap(&self, filename: FileName, src: @str) -> @FileMap {
         return self.new_filemap_w_substr(filename, FssNone, src);
     }
 
     pub fn new_filemap_w_substr(&self,
                                 filename: FileName,
                                 substr: FileSubstr,
-                                src: @~str)
+                                src: @str)
                                 -> @FileMap {
         let files = &mut *self.files;
         let start_pos = if files.len() == 0 {
@@ -362,7 +362,7 @@ impl CodeMap {
         match (loc.file.substr) {
             FssNone =>
             LocWithOpt {
-                filename: /* FIXME (#2543) */ copy loc.file.name,
+                filename: loc.file.name,
                 line: loc.line,
                 col: loc.col,
                 file: Some(loc.file)},
@@ -421,8 +421,8 @@ impl CodeMap {
                           begin.pos.to_uint(), end.pos.to_uint()).to_owned();
     }
 
-    pub fn get_filemap(&self, filename: ~str) -> @FileMap {
-        for self.files.each |fm| { if fm.name == filename { return *fm; } }
+    pub fn get_filemap(&self, filename: &str) -> @FileMap {
+        for self.files.each |fm| { if filename == fm.name { return *fm; } }
         //XXjdm the following triggers a mismatched type bug
         //      (or expected function, found _|_)
         fail!(); // ("asking for " + filename + " which we don't know about");
@@ -532,7 +532,7 @@ mod test {
     #[test]
     fn t1 () {
         let cm = CodeMap::new();
-        let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line");
+        let fm = cm.new_filemap(@"blork.rs",@"first line.\nsecond line");
         fm.next_line(BytePos(0));
         assert_eq!(&fm.get_line(0),&~"first line.");
         // TESTING BROKEN BEHAVIOR:
@@ -544,7 +544,7 @@ mod test {
     #[should_fail]
     fn t2 () {
         let cm = CodeMap::new();
-        let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line");
+        let fm = cm.new_filemap(@"blork.rs",@"first line.\nsecond line");
         // TESTING *REALLY* BROKEN BEHAVIOR:
         fm.next_line(BytePos(0));
         fm.next_line(BytePos(10));
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 1a2569ef787..36100e3f52f 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -306,8 +306,8 @@ fn highlight_lines(cm: @codemap::CodeMap,
 
 fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
     for sp.expn_info.iter().advance |ei| {
-        let ss = ei.callee.span.map_default(@~"", |span| @cm.span_to_str(*span));
-        print_diagnostic(*ss, note,
+        let ss = ei.callee.span.map_default(~"", |span| cm.span_to_str(*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");
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)));
               }
             }
           }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 9796fcd8bac..035675e523e 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -990,7 +990,7 @@ mod test {
     // make sure idents get transformed everywhere
     #[test] fn ident_transformation () {
         let zz_fold = fun_to_ident_folder(to_zz());
-        let ast = string_to_crate(@~"#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}");
+        let ast = string_to_crate(@"#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}");
         assert_pred!(matches_codepattern,
                      "matches_codepattern",
                      pprust::to_str(zz_fold.fold_crate(ast),fake_print_crate,
@@ -1001,7 +1001,7 @@ mod test {
     // even inside macro defs....
     #[test] fn ident_transformation_in_defs () {
         let zz_fold = fun_to_ident_folder(to_zz());
-        let ast = string_to_crate(@~"macro_rules! a {(b $c:expr $(d $e:token)f+
+        let ast = string_to_crate(@"macro_rules! a {(b $c:expr $(d $e:token)f+
 => (g $(d $d $e)+))} ");
         assert_pred!(matches_codepattern,
                      "matches_codepattern",
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index ed9a83d6b1e..ddcad5c3e8f 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -46,7 +46,7 @@ impl parser_attr for Parser {
               }
               token::DOC_COMMENT(s) => {
                 let attr = ::attr::mk_sugared_doc_attr(
-                    copy *self.id_to_str(s),
+                    self.id_to_str(s),
                     self.span.lo,
                     self.span.hi
                 );
@@ -119,7 +119,7 @@ impl parser_attr for Parser {
               }
               token::DOC_COMMENT(s) => {
                 let attr = ::attr::mk_sugared_doc_attr(
-                    copy *self.id_to_str(s),
+                    self.id_to_str(s),
                     self.span.lo,
                     self.span.hi
                 );
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index a6933c16483..5c56ea6c446 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -320,10 +320,10 @@ pub struct lit {
 // probably not a good thing.
 pub fn gather_comments_and_literals(span_diagnostic:
                                     @diagnostic::span_handler,
-                                    path: ~str,
+                                    path: @str,
                                     srdr: @io::Reader)
                                  -> (~[cmnt], ~[lit]) {
-    let src = @str::from_bytes(srdr.read_whole_stream());
+    let src = str::from_bytes(srdr.read_whole_stream()).to_managed();
     let cm = CodeMap::new();
     let filemap = cm.new_filemap(path, src);
     let rdr = lexer::new_low_level_string_reader(span_diagnostic, filemap);
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index 6027d3b07f2..0956fa7225f 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -158,7 +158,7 @@ impl Parser {
             self.fatal(
                 fmt!(
                     "expected `%s`, found `%s`",
-                    *self.id_to_str(kw.to_ident()),
+                    self.id_to_str(kw.to_ident()),
                     self.this_token_to_str()
                 )
             );
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 474e93ed11a..d71e2763b5c 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -40,7 +40,7 @@ pub struct TokenAndSpan {tok: token::Token, sp: span}
 
 pub struct StringReader {
     span_diagnostic: @span_handler,
-    src: @~str,
+    src: @str,
     // The absolute offset within the codemap of the next character to read
     pos: BytePos,
     // The absolute offset within the codemap of the last character read(curr)
@@ -176,7 +176,7 @@ pub fn with_str_from<T>(rdr: @mut StringReader, start: BytePos, f: &fn(s: &str)
 pub fn bump(rdr: &mut StringReader) {
     rdr.last_pos = rdr.pos;
     let current_byte_offset = byte_offset(rdr, rdr.pos).to_uint();
-    if current_byte_offset < (*rdr.src).len() {
+    if current_byte_offset < (rdr.src).len() {
         assert!(rdr.curr != -1 as char);
         let last_char = rdr.curr;
         let next = rdr.src.char_range_at(current_byte_offset);
@@ -202,7 +202,7 @@ pub fn is_eof(rdr: @mut StringReader) -> bool {
 }
 pub fn nextch(rdr: @mut StringReader) -> char {
     let offset = byte_offset(rdr, rdr.pos).to_uint();
-    if offset < (*rdr.src).len() {
+    if offset < (rdr.src).len() {
         return rdr.src.char_at(offset);
     } else { return -1 as char; }
 }
@@ -801,9 +801,9 @@ mod test {
     }
 
     // open a string reader for the given string
-    fn setup(teststr: ~str) -> Env {
+    fn setup(teststr: @str) -> Env {
         let cm = CodeMap::new();
-        let fm = cm.new_filemap(~"zebra.rs", @teststr);
+        let fm = cm.new_filemap(@"zebra.rs", teststr);
         let span_handler =
             diagnostic::mk_span_handler(diagnostic::mk_handler(None),@cm);
         Env {
@@ -813,7 +813,7 @@ mod test {
 
     #[test] fn t1 () {
         let Env {string_reader} =
-            setup(~"/* my source file */ \
+            setup(@"/* my source file */ \
                     fn main() { io::println(~\"zebra\"); }\n");
         let id = str_to_ident("fn");
         let tok1 = string_reader.next_token();
@@ -849,14 +849,14 @@ mod test {
     }
 
     #[test] fn doublecolonparsing () {
-        let env = setup (~"a b");
+        let env = setup (@"a b");
         check_tokenization (env,
                            ~[mk_ident("a",false),
                              mk_ident("b",false)]);
     }
 
     #[test] fn dcparsing_2 () {
-        let env = setup (~"a::b");
+        let env = setup (@"a::b");
         check_tokenization (env,
                            ~[mk_ident("a",true),
                              token::MOD_SEP,
@@ -864,7 +864,7 @@ mod test {
     }
 
     #[test] fn dcparsing_3 () {
-        let env = setup (~"a ::b");
+        let env = setup (@"a ::b");
         check_tokenization (env,
                            ~[mk_ident("a",false),
                              token::MOD_SEP,
@@ -872,7 +872,7 @@ mod test {
     }
 
     #[test] fn dcparsing_4 () {
-        let env = setup (~"a:: b");
+        let env = setup (@"a:: b");
         check_tokenization (env,
                            ~[mk_ident("a",true),
                              token::MOD_SEP,
@@ -880,28 +880,28 @@ mod test {
     }
 
     #[test] fn character_a() {
-        let env = setup(~"'a'");
+        let env = setup(@"'a'");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
         assert_eq!(tok,token::LIT_INT('a' as i64, ast::ty_char));
     }
 
     #[test] fn character_space() {
-        let env = setup(~"' '");
+        let env = setup(@"' '");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
         assert_eq!(tok, token::LIT_INT(' ' as i64, ast::ty_char));
     }
 
     #[test] fn character_escaped() {
-        let env = setup(~"'\n'");
+        let env = setup(@"'\n'");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
         assert_eq!(tok, token::LIT_INT('\n' as i64, ast::ty_char));
     }
 
     #[test] fn lifetime_name() {
-        let env = setup(~"'abc");
+        let env = setup(@"'abc");
         let TokenAndSpan {tok, sp: _} =
             env.string_reader.next_token();
         let id = token::str_to_ident("abc");
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 559bca34f21..5edd2ec4d47 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -82,38 +82,38 @@ pub fn parse_crate_from_file(
 }
 
 pub fn parse_crate_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     sess: @mut ParseSess
 ) -> @ast::crate {
     let p = new_parser_from_source_str(
         sess,
         /*bad*/ copy cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     maybe_aborted(p.parse_crate_mod(),p)
 }
 
 pub fn parse_expr_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     sess: @mut ParseSess
 ) -> @ast::expr {
     let p = new_parser_from_source_str(
         sess,
         cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     maybe_aborted(p.parse_expr(), p)
 }
 
 pub fn parse_item_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     attrs: ~[ast::attribute],
     sess: @mut ParseSess
@@ -121,30 +121,30 @@ pub fn parse_item_from_source_str(
     let p = new_parser_from_source_str(
         sess,
         cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     maybe_aborted(p.parse_item(attrs),p)
 }
 
 pub fn parse_meta_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     sess: @mut ParseSess
 ) -> @ast::meta_item {
     let p = new_parser_from_source_str(
         sess,
         cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     maybe_aborted(p.parse_meta_item(),p)
 }
 
 pub fn parse_stmt_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     attrs: ~[ast::attribute],
     sess: @mut ParseSess
@@ -152,22 +152,22 @@ pub fn parse_stmt_from_source_str(
     let p = new_parser_from_source_str(
         sess,
         cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     maybe_aborted(p.parse_stmt(attrs),p)
 }
 
 pub fn parse_tts_from_source_str(
-    name: ~str,
-    source: @~str,
+    name: @str,
+    source: @str,
     cfg: ast::crate_cfg,
     sess: @mut ParseSess
 ) -> ~[ast::token_tree] {
     let p = new_parser_from_source_str(
         sess,
         cfg,
-        /*bad*/ copy name,
+        name,
         source
     );
     *p.quote_depth += 1u;
@@ -182,8 +182,8 @@ pub fn parse_tts_from_source_str(
 // result.
 pub fn parse_from_source_str<T>(
     f: &fn(&Parser) -> T,
-    name: ~str, ss: codemap::FileSubstr,
-    source: @~str,
+    name: @str, ss: codemap::FileSubstr,
+    source: @str,
     cfg: ast::crate_cfg,
     sess: @mut ParseSess
 ) -> T {
@@ -213,8 +213,8 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
 // Create a new parser from a source string
 pub fn new_parser_from_source_str(sess: @mut ParseSess,
                                   cfg: ast::crate_cfg,
-                                  name: ~str,
-                                  source: @~str)
+                                  name: @str,
+                                  source: @str)
                                -> Parser {
     filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg)
 }
@@ -223,9 +223,9 @@ pub fn new_parser_from_source_str(sess: @mut ParseSess,
 // is specified as a substring of another file.
 pub fn new_parser_from_source_substr(sess: @mut ParseSess,
                                   cfg: ast::crate_cfg,
-                                  name: ~str,
+                                  name: @str,
                                   ss: codemap::FileSubstr,
-                                  source: @~str)
+                                  source: @str)
                                -> Parser {
     filemap_to_parser(sess,substring_to_filemap(sess,source,name,ss),cfg)
 }
@@ -275,7 +275,7 @@ pub fn new_parser_from_tts(sess: @mut ParseSess,
 pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<span>)
     -> @FileMap {
     match io::read_whole_file_str(path) {
-        Ok(src) => string_to_filemap(sess, @src, path.to_str()),
+        Ok(src) => string_to_filemap(sess, src.to_managed(), path.to_str().to_managed()),
         Err(e) => {
             match spanopt {
                 Some(span) => sess.span_diagnostic.span_fatal(span, e),
@@ -287,14 +287,14 @@ pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<span>)
 
 // given a session and a string, add the string to
 // the session's codemap and return the new filemap
-pub fn string_to_filemap(sess: @mut ParseSess, source: @~str, path: ~str)
+pub fn string_to_filemap(sess: @mut ParseSess, source: @str, path: @str)
     -> @FileMap {
     sess.cm.new_filemap(path, source)
 }
 
 // given a session and a string and a path and a FileSubStr, add
 // the string to the CodeMap and return the new FileMap
-pub fn substring_to_filemap(sess: @mut ParseSess, source: @~str, path: ~str,
+pub fn substring_to_filemap(sess: @mut ParseSess, source: @str, path: @str,
                            filesubstr: FileSubstr) -> @FileMap {
     sess.cm.new_filemap_w_substr(path,filesubstr,source)
 }
@@ -349,7 +349,7 @@ mod test {
     use util::parser_testing::{string_to_stmt, strs_to_idents};
 
     // map a string to tts, return the tt without its parsesess
-    fn string_to_tts_only(source_str : @~str) -> ~[ast::token_tree] {
+    fn string_to_tts_only(source_str : @str) -> ~[ast::token_tree] {
         let (tts,_ps) = string_to_tts_and_sess(source_str);
         tts
     }
@@ -368,7 +368,7 @@ mod test {
     }
 
     #[test] fn path_exprs_1 () {
-        assert_eq!(string_to_expr(@~"a"),
+        assert_eq!(string_to_expr(@"a"),
                    @ast::expr{id:1,
                               node:ast::expr_path(@ast::Path {span:sp(0,1),
                                                               global:false,
@@ -379,7 +379,7 @@ mod test {
     }
 
     #[test] fn path_exprs_2 () {
-        assert_eq!(string_to_expr(@~"::a::b"),
+        assert_eq!(string_to_expr(@"::a::b"),
                    @ast::expr{id:1,
                                node:ast::expr_path(
                                    @ast::Path {span:sp(0,6),
@@ -394,11 +394,11 @@ mod test {
     // marked as `#[should_fail]`.
     /*#[should_fail]
     #[test] fn bad_path_expr_1() {
-        string_to_expr(@~"::abc::def::return");
+        string_to_expr(@"::abc::def::return");
     }*/
 
     #[test] fn string_to_tts_1 () {
-        let (tts,_ps) = string_to_tts_and_sess(@~"fn a (b : int) { b; }");
+        let (tts,_ps) = string_to_tts_and_sess(@"fn a (b : int) { b; }");
         assert_eq!(to_json_str(@tts),
                    ~"[\
                 [\"tt_tok\",null,[\"IDENT\",\"fn\",false]],\
@@ -427,7 +427,7 @@ mod test {
     }
 
     #[test] fn ret_expr() {
-        assert_eq!(string_to_expr(@~"return d"),
+        assert_eq!(string_to_expr(@"return d"),
                    @ast::expr{id:2,
                               node:ast::expr_ret(
                                   Some(@ast::expr{id:1,
@@ -443,7 +443,7 @@ mod test {
     }
 
     #[test] fn parse_stmt_1 () {
-        assert_eq!(string_to_stmt(@~"b;"),
+        assert_eq!(string_to_stmt(@"b;"),
                    @spanned{
                        node: ast::stmt_expr(@ast::expr{
                            id: 1,
@@ -465,7 +465,7 @@ mod test {
     }
 
     #[test] fn parse_ident_pat () {
-        let parser = string_to_parser(@~"b");
+        let parser = string_to_parser(@"b");
         assert_eq!(parser.parse_pat(),
                    @ast::pat{id:1, // fixme
                              node: ast::pat_ident(ast::bind_infer,
@@ -482,7 +482,7 @@ mod test {
     }
 
     #[test] fn parse_arg () {
-        let parser = string_to_parser(@~"b : int");
+        let parser = string_to_parser(@"b : int");
         assert_eq!(parser.parse_arg_general(true),
                    ast::arg{
                        is_mutbl: false,
@@ -515,7 +515,7 @@ mod test {
     #[test] fn parse_fundecl () {
         // this test depends on the intern order of "fn" and "int", and on the
         // assignment order of the node_ids.
-        assert_eq!(string_to_item(@~"fn a (b : int) { b; }"),
+        assert_eq!(string_to_item(@"fn a (b : int) { b; }"),
                   Some(
                       @ast::item{ident:str_to_ident("a"),
                             attrs:~[],
@@ -585,12 +585,12 @@ mod test {
 
     #[test] fn parse_exprs () {
         // just make sure that they parse....
-        string_to_expr(@~"3 + 4");
-        string_to_expr(@~"a::z.froob(b,@(987+3))");
+        string_to_expr(@"3 + 4");
+        string_to_expr(@"a::z.froob(b,@(987+3))");
     }
 
     #[test] fn attrs_fix_bug () {
-        string_to_item(@~"pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
+        string_to_item(@"pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
                    -> Result<@Writer, ~str> {
     #[cfg(windows)]
     fn wb() -> c_int {
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 61b7f1403e6..cc7b7fab07e 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -259,7 +259,7 @@ impl Parser {
                                    -> bool {
         match *token {
             token::IDENT(sid, _) => {
-                str::eq_slice(*self.id_to_str(sid), ident)
+                str::eq_slice(self.id_to_str(sid), ident)
             }
             _ => false
         }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 8dd80be4f9c..47c0827eb23 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -96,7 +96,6 @@ use core::iterator::IteratorUtil;
 use core::either::Either;
 use core::either;
 use core::hashmap::HashSet;
-use core::str;
 use core::vec;
 
 #[deriving(Eq)]
@@ -263,7 +262,7 @@ pub struct Parser {
     /// extra detail when the same error is seen twice
     obsolete_set: @mut HashSet<ObsoleteSyntax>,
     /// Used to determine the path to externally loaded source files
-    mod_path_stack: @mut ~[~str],
+    mod_path_stack: @mut ~[@str],
 
 }
 
@@ -333,7 +332,7 @@ impl Parser {
     }
     pub fn get_id(&self) -> node_id { next_node_id(self.sess) }
 
-    pub fn id_to_str(&self, id: ident) -> @~str {
+    pub fn id_to_str(&self, id: ident) -> @str {
         get_ident_interner().get(id.name)
     }
 
@@ -2886,7 +2885,7 @@ impl Parser {
         loop {
             match *self.token {
                 token::LIFETIME(lifetime) => {
-                    if str::eq_slice(*self.id_to_str(lifetime), "static") {
+                    if "static" == self.id_to_str(lifetime) {
                         result.push(RegionTyParamBound);
                     } else {
                         self.span_err(*self.span,
@@ -2898,11 +2897,11 @@ impl Parser {
                     let obsolete_bound = match *self.token {
                         token::MOD_SEP => false,
                         token::IDENT(sid, _) => {
-                            match *self.id_to_str(sid) {
-                                ~"send" |
-                                ~"copy" |
-                                ~"const" |
-                                ~"owned" => {
+                            match self.id_to_str(sid).as_slice() {
+                                "send" |
+                                "copy" |
+                                "const" |
+                                "owned" => {
                                     self.obsolete(
                                         *self.span,
                                         ObsoleteLowerCaseKindBounds);
@@ -3364,7 +3363,7 @@ impl Parser {
             }
             if fields.len() == 0 {
                 self.fatal(fmt!("Unit-like struct should be written as `struct %s;`",
-                                *get_ident_interner().get(class_name.name)));
+                                get_ident_interner().get(class_name.name)));
             }
             self.bump();
         } else if *self.token == token::LPAREN {
@@ -3580,8 +3579,8 @@ impl Parser {
         let file_path = match ::attr::first_attr_value_str_by_name(
             attrs, "path") {
 
-            Some(d) => copy *d,
-            None => copy *default_path
+            Some(d) => d,
+            None => default_path
         };
         self.mod_path_stack.push(file_path)
     }
@@ -3599,13 +3598,13 @@ impl Parser {
         let prefix = prefix.dir_path();
         let mod_path_stack = &*self.mod_path_stack;
         let mod_path = Path(".").push_many(*mod_path_stack);
-        let default_path = *token::interner_get(id.name) + ".rs";
+        let default_path = token::interner_get(id.name).to_owned() + ".rs";
         let file_path = match ::attr::first_attr_value_str_by_name(
             outer_attrs, "path") {
             Some(d) => {
-                let path = Path(copy *d);
+                let path = Path(d);
                 if !path.is_absolute {
-                    mod_path.push(copy *d)
+                    mod_path.push(d)
                 } else {
                     path
                 }
@@ -3637,9 +3636,9 @@ impl Parser {
         let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
         return (ast::item_mod(m0), mod_attrs);
 
-        fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str {
+        fn cdir_path_opt(default: @str, attrs: ~[ast::attribute]) -> @str {
             match ::attr::first_attr_value_str_by_name(attrs, "path") {
-                Some(d) => copy *d,
+                Some(d) => d,
                 None => default
             }
         }
@@ -4263,7 +4262,7 @@ impl Parser {
 
         let first_ident = self.parse_ident();
         let mut path = ~[first_ident];
-        debug!("parsed view_path: %s", *self.id_to_str(first_ident));
+        debug!("parsed view_path: %s", self.id_to_str(first_ident));
         match *self.token {
           token::EQ => {
             // x = foo::bar
@@ -4528,7 +4527,7 @@ impl Parser {
                                config: copy self.cfg })
     }
 
-    pub fn parse_str(&self) -> @~str {
+    pub fn parse_str(&self) -> @str {
         match *self.token {
             token::LIT_STR(s) => {
                 self.bump();
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 91605db77b5..e7bc67340f0 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -21,10 +21,8 @@ use core::cast;
 use core::char;
 use core::cmp::Equiv;
 use core::local_data;
-use core::str;
 use core::rand;
 use core::rand::RngUtil;
-use core::to_bytes;
 
 #[deriving(Encodable, Decodable, Eq)]
 pub enum binop {
@@ -180,28 +178,28 @@ pub fn to_str(in: @ident_interner, t: &Token) -> ~str {
       }
       LIT_INT_UNSUFFIXED(i) => { i.to_str() }
       LIT_FLOAT(ref s, t) => {
-        let mut body = copy *ident_to_str(s);
+        let mut body = ident_to_str(s).to_owned();
         if body.ends_with(".") {
             body += "0";  // `10.f` is not a float literal
         }
         body + ast_util::float_ty_to_str(t)
       }
       LIT_FLOAT_UNSUFFIXED(ref s) => {
-        let mut body = copy *ident_to_str(s);
+        let mut body = ident_to_str(s).to_owned();
         if body.ends_with(".") {
             body += "0";  // `10.f` is not a float literal
         }
         body
       }
-      LIT_STR(ref s) => { ~"\"" + ident_to_str(s).escape_default() + "\"" }
+      LIT_STR(ref s) => { fmt!("\"%s\"", ident_to_str(s).escape_default()) }
 
       /* Name components */
-      IDENT(s, _) => copy *in.get(s.name),
-      LIFETIME(s) => fmt!("'%s", *in.get(s.name)),
+      IDENT(s, _) => in.get(s.name).to_owned(),
+      LIFETIME(s) => fmt!("'%s", in.get(s.name)),
       UNDERSCORE => ~"_",
 
       /* Other */
-      DOC_COMMENT(ref s) => copy *ident_to_str(s),
+      DOC_COMMENT(ref s) => ident_to_str(s).to_owned(),
       EOF => ~"<eof>",
       INTERPOLATED(ref nt) => {
         match nt {
@@ -350,20 +348,6 @@ pub mod special_idents {
     pub static type_self: ident = ident { name: 34, ctxt: 0};    // `Self`
 }
 
-pub struct StringRef<'self>(&'self str);
-
-impl<'self> Equiv<@~str> for StringRef<'self> {
-    #[inline(always)]
-    fn equiv(&self, other: &@~str) -> bool { str::eq_slice(**self, **other) }
-}
-
-impl<'self> to_bytes::IterBytes for StringRef<'self> {
-    #[inline(always)]
-    fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        (**self).iter_bytes(lsb0, f)
-    }
-}
-
 /**
  * Maps a token to a record specifying the corresponding binary
  * operator
@@ -403,14 +387,14 @@ impl ident_interner {
     pub fn gensym(&self, val: &str) -> Name {
         self.interner.gensym(val)
     }
-    pub fn get(&self, idx: Name) -> @~str {
+    pub fn get(&self, idx: Name) -> @str {
         self.interner.get(idx)
     }
     // is this really something that should be exposed?
     pub fn len(&self) -> uint {
         self.interner.len()
     }
-    pub fn find_equiv<Q:Hash + IterBytes + Equiv<@~str>>(&self, val: &Q)
+    pub fn find_equiv<Q:Hash + IterBytes + Equiv<@str>>(&self, val: &Q)
                                                      -> Option<Name> {
         self.interner.find_equiv(val)
     }
@@ -542,12 +526,12 @@ pub fn gensym(str : &str) -> Name {
 }
 
 // map an interned representation back to a string
-pub fn interner_get(name : Name) -> @~str {
+pub fn interner_get(name : Name) -> @str {
     get_ident_interner().get(name)
 }
 
 // maps an identifier to the string that it corresponds to
-pub fn ident_to_str(id : &ast::ident) -> @~str {
+pub fn ident_to_str(id : &ast::ident) -> @str {
     interner_get(id.name)
 }
 
@@ -715,6 +699,6 @@ mod test {
     #[test] fn t1() {
         let a = fresh_name("ghi");
         io::println(fmt!("interned name: %u,\ntextual name: %s\n",
-                         a,*interner_get(a)));
+                         a,interner_get(a)));
     }
 }
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index f6059980697..7853e7e312d 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -80,7 +80,7 @@ pub struct begin_t {
 }
 
 pub enum token {
-    STRING(@~str, int),
+    STRING(@str, int),
     BREAK(break_t),
     BEGIN(begin_t),
     END,
@@ -107,7 +107,7 @@ impl token {
 
 pub fn tok_str(t: token) -> ~str {
     match t {
-        STRING(s, len) => return fmt!("STR(%s,%d)", *s, len),
+        STRING(s, len) => return fmt!("STR(%s,%d)", s, len),
         BREAK(_) => return ~"BREAK",
         BEGIN(_) => return ~"BEGIN",
         END => return ~"END",
@@ -335,11 +335,11 @@ impl Printer {
           STRING(s, len) => {
             if self.scan_stack_empty {
                 debug!("pp STRING('%s')/print ~[%u,%u]",
-                       *s, self.left, self.right);
+                       s, self.left, self.right);
                 self.print(t, len);
             } else {
                 debug!("pp STRING('%s')/buffer ~[%u,%u]",
-                       *s, self.left, self.right);
+                       s, self.left, self.right);
                 self.advance_right();
                 self.token[self.right] = t;
                 self.size[self.right] = len;
@@ -534,11 +534,11 @@ impl Printer {
             }
           }
           STRING(s, len) => {
-            debug!("print STRING(%s)", *s);
+            debug!("print STRING(%s)", s);
             assert_eq!(L, len);
             // assert!(L <= space);
             self.space -= len;
-            self.print_str(*s);
+            self.print_str(s);
           }
           EOF => {
             // EOF should never get here.
@@ -572,15 +572,15 @@ pub fn end(p: @mut Printer) { p.pretty_print(END); }
 pub fn eof(p: @mut Printer) { p.pretty_print(EOF); }
 
 pub fn word(p: @mut Printer, wrd: &str) {
-    p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), wrd.len() as int));
+    p.pretty_print(STRING(/* bad */ wrd.to_managed(), wrd.len() as int));
 }
 
 pub fn huge_word(p: @mut Printer, wrd: &str) {
-    p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), size_infinity));
+    p.pretty_print(STRING(/* bad */ wrd.to_managed(), size_infinity));
 }
 
 pub fn zero_word(p: @mut Printer, wrd: &str) {
-    p.pretty_print(STRING(@/*bad*/ wrd.to_owned(), 0));
+    p.pretty_print(STRING(/* bad */ wrd.to_managed(), 0));
 }
 
 pub fn spaces(p: @mut Printer, n: uint) { break_offset(p, n, 0); }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index ea33c04dbb5..c2a537dd10d 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -111,14 +111,14 @@ pub fn print_crate(cm: @CodeMap,
                    intr: @ident_interner,
                    span_diagnostic: @diagnostic::span_handler,
                    crate: @ast::crate,
-                   filename: ~str,
+                   filename: @str,
                    in: @io::Reader,
                    out: @io::Writer,
                    ann: pp_ann,
                    is_expanded: bool) {
     let (cmnts, lits) = comments::gather_comments_and_literals(
         span_diagnostic,
-        copy filename,
+        filename,
         in
     );
     let s = @ps {
@@ -860,7 +860,7 @@ pub fn print_attribute(s: @ps, attr: ast::attribute) {
     if attr.node.is_sugared_doc {
         let meta = attr::attr_meta(attr);
         let comment = attr::get_meta_item_value_str(meta).get();
-        word(s.s, *comment);
+        word(s.s, comment);
     } else {
         word(s.s, "#[");
         print_meta_item(s, attr.node.value);
@@ -1400,10 +1400,10 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
             word(s.s, "asm!");
         }
         popen(s);
-        print_string(s, *a.asm);
+        print_string(s, a.asm);
         word_space(s, ":");
         for a.outputs.each |&(co, o)| {
-            print_string(s, *co);
+            print_string(s, co);
             popen(s);
             print_expr(s, o);
             pclose(s);
@@ -1411,14 +1411,14 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
         }
         word_space(s, ":");
         for a.inputs.each |&(co, o)| {
-            print_string(s, *co);
+            print_string(s, co);
             popen(s);
             print_expr(s, o);
             pclose(s);
             word_space(s, ",");
         }
         word_space(s, ":");
-        print_string(s, *a.clobbers);
+        print_string(s, a.clobbers);
         pclose(s);
       }
       ast::expr_mac(ref m) => print_mac(s, m),
@@ -1474,7 +1474,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
 }
 
 pub fn print_ident(s: @ps, ident: ast::ident) {
-    word(s.s, *ident_to_str(&ident));
+    word(s.s, ident_to_str(&ident));
 }
 
 pub fn print_for_decl(s: @ps, loc: @ast::local, coll: @ast::expr) {
@@ -1776,14 +1776,14 @@ pub fn print_generics(s: @ps, generics: &ast::Generics) {
 pub fn print_meta_item(s: @ps, item: @ast::meta_item) {
     ibox(s, indent_unit);
     match item.node {
-      ast::meta_word(name) => word(s.s, *name),
+      ast::meta_word(name) => word(s.s, name),
       ast::meta_name_value(name, value) => {
-        word_space(s, *name);
+        word_space(s, name);
         word_space(s, "=");
         print_literal(s, @value);
       }
       ast::meta_list(name, ref items) => {
-        word(s.s, *name);
+        word(s.s, name);
         popen(s);
         commasep(
             s,
@@ -1995,7 +1995,7 @@ pub fn print_literal(s: @ps, lit: @ast::lit) {
       _ => ()
     }
     match lit.node {
-      ast::lit_str(st) => print_string(s, *st),
+      ast::lit_str(st) => print_string(s, st),
       ast::lit_int(ch, ast::ty_char) => {
         word(s.s, ~"'" + char::escape_default(ch as char) + "'");
       }
@@ -2023,9 +2023,9 @@ pub fn print_literal(s: @ps, lit: @ast::lit) {
         }
       }
       ast::lit_float(f, t) => {
-        word(s.s, *f + ast_util::float_ty_to_str(t));
+        word(s.s, f.to_owned() + ast_util::float_ty_to_str(t));
       }
-      ast::lit_float_unsuffixed(f) => word(s.s, *f),
+      ast::lit_float_unsuffixed(f) => word(s.s, f),
       ast::lit_nil => word(s.s, "()"),
       ast::lit_bool(val) => {
         if val { word(s.s, "true"); } else { word(s.s, "false"); }
@@ -2101,7 +2101,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
         // We need to do at least one, possibly two hardbreaks.
         let is_semi =
             match s.s.last_token() {
-              pp::STRING(s, _) => *s == ~";",
+              pp::STRING(s, _) => ";" == s,
               _ => false
             };
         if is_semi || is_begin(s) || is_end(s) { hardbreak(s.s); }
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index b55050184fe..d4f183ada7b 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -19,7 +19,6 @@ use core::prelude::*;
 
 use core::cmp::Equiv;
 use core::hashmap::HashMap;
-use syntax::parse::token::StringRef;
 
 pub struct Interner<T> {
     priv map: @mut HashMap<T, uint>,
@@ -80,8 +79,8 @@ impl<T:Eq + IterBytes + Hash + Const + Copy> Interner<T> {
 // A StrInterner differs from Interner<String> in that it accepts
 // borrowed pointers rather than @ ones, resulting in less allocation.
 pub struct StrInterner {
-    priv map: @mut HashMap<@~str, uint>,
-    priv vect: @mut ~[@~str],
+    priv map: @mut HashMap<@str, uint>,
+    priv vect: @mut ~[@str],
 }
 
 // when traits can extend traits, we should extend index<uint,T> to get []
@@ -95,37 +94,38 @@ impl StrInterner {
 
     pub fn prefill(init: &[&str]) -> StrInterner {
         let rv = StrInterner::new();
-        for init.each() |v| { rv.intern(*v); }
+        for init.each |&v| { rv.intern(v); }
         rv
     }
 
     pub fn intern(&self, val: &str) -> uint {
-        match self.map.find_equiv(&StringRef(val)) {
+        match self.map.find_equiv(&val) {
             Some(&idx) => return idx,
             None => (),
         }
 
         let new_idx = self.len();
-        self.map.insert(@val.to_owned(), new_idx);
-        self.vect.push(@val.to_owned());
+        let val = val.to_managed();
+        self.map.insert(val, new_idx);
+        self.vect.push(val);
         new_idx
     }
 
     pub fn gensym(&self, val: &str) -> uint {
         let new_idx = self.len();
         // leave out of .map to avoid colliding
-        self.vect.push(@val.to_owned());
+        self.vect.push(val.to_managed());
         new_idx
     }
 
     // this isn't "pure" in the traditional sense, because it can go from
     // failing to returning a value as items are interned. But for typestate,
     // where we first check a pred and then rely on it, ceasing to fail is ok.
-    pub fn get(&self, idx: uint) -> @~str { self.vect[idx] }
+    pub fn get(&self, idx: uint) -> @str { self.vect[idx] }
 
     pub fn len(&self) -> uint { let vect = &*self.vect; vect.len() }
 
-    pub fn find_equiv<Q:Hash + IterBytes + Equiv<@~str>>(&self, val: &Q)
+    pub fn find_equiv<Q:Hash + IterBytes + Equiv<@str>>(&self, val: &Q)
                                                          -> Option<uint> {
         match self.map.find_equiv(val) {
             Some(v) => Some(*v),
@@ -140,41 +140,41 @@ mod tests {
     #[test]
     #[should_fail]
     fn i1 () {
-        let i : Interner<@~str> = Interner::new();
+        let i : Interner<@str> = Interner::new();
         i.get(13);
     }
 
     #[test]
     fn i2 () {
-        let i : Interner<@~str> = Interner::new();
+        let i : Interner<@str> = Interner::new();
         // first one is zero:
-        assert_eq!(i.intern (@~"dog"), 0);
+        assert_eq!(i.intern (@"dog"), 0);
         // re-use gets the same entry:
-        assert_eq!(i.intern (@~"dog"), 0);
+        assert_eq!(i.intern (@"dog"), 0);
         // different string gets a different #:
-        assert_eq!(i.intern (@~"cat"), 1);
-        assert_eq!(i.intern (@~"cat"), 1);
+        assert_eq!(i.intern (@"cat"), 1);
+        assert_eq!(i.intern (@"cat"), 1);
         // dog is still at zero
-        assert_eq!(i.intern (@~"dog"), 0);
+        assert_eq!(i.intern (@"dog"), 0);
         // gensym gets 3
-        assert_eq!(i.gensym (@~"zebra" ), 2);
+        assert_eq!(i.gensym (@"zebra" ), 2);
         // gensym of same string gets new number :
-        assert_eq!(i.gensym (@~"zebra" ), 3);
+        assert_eq!(i.gensym (@"zebra" ), 3);
         // gensym of *existing* string gets new number:
-        assert_eq!(i.gensym (@~"dog"), 4);
-        assert_eq!(i.get(0), @~"dog");
-        assert_eq!(i.get(1), @~"cat");
-        assert_eq!(i.get(2), @~"zebra");
-        assert_eq!(i.get(3), @~"zebra");
-        assert_eq!(i.get(4), @~"dog");
+        assert_eq!(i.gensym (@"dog"), 4);
+        assert_eq!(i.get(0), @"dog");
+        assert_eq!(i.get(1), @"cat");
+        assert_eq!(i.get(2), @"zebra");
+        assert_eq!(i.get(3), @"zebra");
+        assert_eq!(i.get(4), @"dog");
     }
 
     #[test]
     fn i3 () {
-        let i : Interner<@~str> = Interner::prefill([@~"Alan",@~"Bob",@~"Carol"]);
-        assert_eq!(i.get(0), @~"Alan");
-        assert_eq!(i.get(1), @~"Bob");
-        assert_eq!(i.get(2), @~"Carol");
-        assert_eq!(i.intern(@~"Bob"), 1);
+        let i : Interner<@str> = Interner::prefill([@"Alan",@"Bob",@"Carol"]);
+        assert_eq!(i.get(0), @"Alan");
+        assert_eq!(i.get(1), @"Bob");
+        assert_eq!(i.get(2), @"Carol");
+        assert_eq!(i.intern(@"Bob"), 1);
     }
 }
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs
index 76055ca7914..d0961ddbc70 100644
--- a/src/libsyntax/util/parser_testing.rs
+++ b/src/libsyntax/util/parser_testing.rs
@@ -18,50 +18,50 @@ use parse::token;
 
 // map a string to tts, using a made-up filename: return both the token_trees
 // and the ParseSess
-pub fn string_to_tts_and_sess (source_str : @~str) -> (~[ast::token_tree],@mut ParseSess) {
+pub fn string_to_tts_and_sess (source_str : @str) -> (~[ast::token_tree],@mut ParseSess) {
     let ps = new_parse_sess(None);
-    (filemap_to_tts(ps,string_to_filemap(ps,source_str,~"bogofile")),ps)
+    (filemap_to_tts(ps,string_to_filemap(ps,source_str,@"bogofile")),ps)
 }
 
-pub fn string_to_parser_and_sess(source_str: @~str) -> (Parser,@mut ParseSess) {
+pub fn string_to_parser_and_sess(source_str: @str) -> (Parser,@mut ParseSess) {
     let ps = new_parse_sess(None);
-    (new_parser_from_source_str(ps,~[],~"bogofile",source_str),ps)
+    (new_parser_from_source_str(ps,~[],@"bogofile",source_str),ps)
 }
 
 // map string to parser (via tts)
-pub fn string_to_parser(source_str: @~str) -> Parser {
+pub fn string_to_parser(source_str: @str) -> Parser {
     let (p,_) = string_to_parser_and_sess(source_str);
     p
 }
 
-pub fn string_to_crate (source_str : @~str) -> @ast::crate {
+pub fn string_to_crate (source_str : @str) -> @ast::crate {
     string_to_parser(source_str).parse_crate_mod()
 }
 
 // parse a string, return an expr
-pub fn string_to_expr (source_str : @~str) -> @ast::expr {
+pub fn string_to_expr (source_str : @str) -> @ast::expr {
     string_to_parser(source_str).parse_expr()
 }
 
 // parse a string, return an item
-pub fn string_to_item (source_str : @~str) -> Option<@ast::item> {
+pub fn string_to_item (source_str : @str) -> Option<@ast::item> {
     string_to_parser(source_str).parse_item(~[])
 }
 
 // parse a string, return an item and the ParseSess
-pub fn string_to_item_and_sess (source_str : @~str) -> (Option<@ast::item>,@mut ParseSess) {
+pub fn string_to_item_and_sess (source_str : @str) -> (Option<@ast::item>,@mut ParseSess) {
     let (p,ps) = string_to_parser_and_sess(source_str);
     (p.parse_item(~[]),ps)
 }
 
 // parse a string, return a stmt
-pub fn string_to_stmt(source_str : @~str) -> @ast::stmt {
+pub fn string_to_stmt(source_str : @str) -> @ast::stmt {
     string_to_parser(source_str).parse_stmt(~[])
 }
 
 // parse a string, return a pat. Uses "irrefutable"... which doesn't
 // (currently) affect parsing.
-pub fn string_to_pat(source_str : @~str) -> @ast::pat {
+pub fn string_to_pat(source_str : @str) -> @ast::pat {
     string_to_parser(source_str).parse_pat()
 }