convert ast::meta_items to take @~strs

src/librustc/back/link.rs

@@ -499,15 +499,15 @@ pub fn build_link_meta(sess: Session, c: &ast::crate, output: &Path,
 
         fn hash(symbol_hasher: &hash::State, m: &@ast::meta_item) {
             match m.node {
-              ast::meta_name_value(ref key, value) => {
+              ast::meta_name_value(key, value) => {
-                symbol_hasher.write_str(len_and_str((*key)));
+                symbol_hasher.write_str(len_and_str(*key));
                 symbol_hasher.write_str(len_and_str_lit(value));
               }
-              ast::meta_word(ref name) => {
+              ast::meta_word(name) => {
-                symbol_hasher.write_str(len_and_str((*name)));
+                symbol_hasher.write_str(len_and_str(*name));
               }
-              ast::meta_list(ref name, ref mis) => {
+              ast::meta_list(name, ref mis) => {
-                symbol_hasher.write_str(len_and_str((*name)));
+                symbol_hasher.write_str(len_and_str(*name));
                 for mis.each |m_| {
                     hash(symbol_hasher, m_);
                 }

src/librustc/driver/session.rs

@@ -346,7 +346,7 @@ pub mod test {
             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)))),
             is_sugared_doc: false

src/librustc/front/core_inject.rs

@@ -51,7 +51,7 @@ fn inject_libcore_ref(sess: Session,
                     spanned(ast::attribute_ {
                         style: ast::attr_inner,
                         value: spanned(ast::meta_name_value(
-                            ~"vers",
+                            @~"vers",
                             spanned(ast::lit_str(@CORE_VERSION.to_str()))
                         )),
                         is_sugared_doc: false

src/librustc/front/test.rs

@@ -262,7 +262,7 @@ mod __test {
 fn mk_std(cx: &TestCtxt) -> @ast::view_item {
     let vers = ast::lit_str(@~"0.6");
     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(~"std");
     let vi = if is_std(cx) {

src/librustc/metadata/encoder.rs

@@ -1017,19 +1017,19 @@ fn write_int(writer: io::Writer, &&n: int) {
 
 fn encode_meta_item(ebml_w: writer::Encoder, mi: meta_item) {
     match mi.node {
-      meta_word(ref name) => {
+      meta_word(name) => {
         ebml_w.start_tag(tag_meta_item_word);
         ebml_w.start_tag(tag_meta_item_name);
-        ebml_w.writer.write(str::to_bytes((*name)));
+        ebml_w.writer.write(str::to_bytes(*name));
         ebml_w.end_tag();
         ebml_w.end_tag();
       }
-      meta_name_value(ref name, value) => {
+      meta_name_value(name, value) => {
         match value.node {
           lit_str(value) => {
             ebml_w.start_tag(tag_meta_item_name_value);
             ebml_w.start_tag(tag_meta_item_name);
-            ebml_w.writer.write(str::to_bytes((*name)));
+            ebml_w.writer.write(str::to_bytes(*name));
             ebml_w.end_tag();
             ebml_w.start_tag(tag_meta_item_value);
             ebml_w.writer.write(str::to_bytes(*value));
@@ -1039,10 +1039,10 @@ fn encode_meta_item(ebml_w: writer::Encoder, mi: meta_item) {
           _ => {/* FIXME (#623): encode other variants */ }
         }
       }
-      meta_list(ref name, ref items) => {
+      meta_list(name, ref items) => {
         ebml_w.start_tag(tag_meta_item_list);
         ebml_w.start_tag(tag_meta_item_name);
-        ebml_w.writer.write(str::to_bytes((*name)));
+        ebml_w.writer.write(str::to_bytes(*name));
         ebml_w.end_tag();
         for items.each |inner_item| {
             encode_meta_item(ebml_w, **inner_item);

src/librustc/middle/lang_items.rs

@@ -321,7 +321,7 @@ impl LanguageItemCollector {
                 match literal.node {
                     lit_str(value) => {
                         self.match_and_collect_item(item_def_id,
-                                                    (/*bad*/copy *key),
+                                                    (/*bad*/copy **key),
                                                     /*bad*/copy *value);
                     }
                     _ => {} // Skip.

src/librustc/middle/lint.rs

@@ -346,13 +346,13 @@ impl ctxt {
 
         for triples.each |pair| {
             let (meta, level, lintname) = /*bad*/copy *pair;
-            match self.dict.find(&lintname) {
+            match self.dict.find(&*lintname) {
               None => {
                 self.span_lint(
                     new_ctxt.get_level(unrecognized_lint),
                     meta.span,
                     fmt!("unknown `%s` attribute: `%s`",
-                         level_to_str(level), lintname));
+                         level_to_str(level), *lintname));
               }
               Some(lint) => {
 
@@ -363,7 +363,7 @@ impl ctxt {
                         meta.span,
                         fmt!("%s(%s) overruled by outer forbid(%s)",
                              level_to_str(level),
-                             lintname, lintname));
+                             *lintname, *lintname));
                 }
 
                 // we do multiple unneeded copies of the

src/librustc/middle/ty.rs

@@ -783,11 +783,11 @@ pub fn mk_ctxt(s: session::Session,
     let mut legacy_records = false;
     for crate.node.attrs.each |attribute| {
         match attribute.node.value.node {
-            ast::meta_word(ref w) if (*w) == ~"legacy_modes" => {
+            ast::meta_word(w) if *w == ~"legacy_modes" => {
                 legacy_modes = true;
                 if legacy_records { break; }
             }
-            ast::meta_word(ref w) if (*w) == ~"legacy_records" => {
+            ast::meta_word(w) if *w == ~"legacy_records" => {
                 legacy_records = true;
                 if legacy_modes { break; }
             }

src/librustpkg/rustpkg.rc

@@ -89,7 +89,7 @@ impl PackageScript {
                     ast::meta_name_value(v, spanned {
                                                 node: ast::lit_str(s),
                                                 span: _}) => {
-                        match v {
+                        match *v {
                             ~"id" => id = Some(*s),
                             ~"vers" => vers = Some(*s),
                             _ => ()
@@ -112,7 +112,7 @@ impl PackageScript {
                     ast::meta_name_value(v, spanned {
                                                 node: ast::lit_str(s),
                                                 span: _}) => {
-                        match v {
+                        match *v {
                             ~"url" => url = Some(*s),
                             ~"target" => target = Some(*s),
                             _ => ()
@@ -133,7 +133,7 @@ impl PackageScript {
                     ast::meta_name_value(v, spanned {
                                                 node: ast::lit_str(s),
                                                 span: _}) => {
-                        match v {
+                        match *v {
                             ~"file" => file = Some(*s),
                             _ => ()
                         }
@@ -148,7 +148,7 @@ impl PackageScript {
         for crate.node.attrs.each |a| {
             match a.node.value.node {
                 ast::meta_list(v, mis) => {
-                    match v {
+                    match *v {
                         ~"pkg" => {
                             let (i, v) = load_pkg_attr(mis);
 

src/librustpkg/util.rs

@@ -110,7 +110,7 @@ fn fold_item(ctx: @ReadyCtx, item: @ast::item,
                 ast::meta_list(_, mis) => {
                     for mis.each |mi| {
                         match mi.node {
-                            ast::meta_word(cmd) => cmds.push(cmd),
+                            ast::meta_word(cmd) => cmds.push(copy *cmd),
                             _ => {}
                         };
                     }
@@ -639,7 +639,7 @@ pub fn compile_input(sysroot: Option<Path>, input: driver::input, dir: &Path,
             match a.node {
                 ast::meta_name_value(v, spanned {node: ast::lit_str(s),
                                          span: _}) => {
-                    match v {
+                    match *v {
                         ~"name" => name = Some(*s),
                         ~"vers" => vers = Some(*s),
                         ~"uuid" => uuid = Some(*s),
@@ -657,13 +657,13 @@ pub fn compile_input(sysroot: Option<Path>, input: driver::input, dir: &Path,
         match a.node.value.node {
             ast::meta_name_value(v, spanned {node: ast::lit_str(s),
                                      span: _}) => {
-                match v {
+                match *v {
                     ~"crate_type" => crate_type = Some(*s),
                     _ => {}
                 }
             }
             ast::meta_list(v, mis) => {
-                match v {
+                match *v {
                     ~"link" => {
                         let (n, v, u) = load_link_attr(mis);
 

src/libsyntax/ast.rs

@@ -173,9 +173,9 @@ pub type meta_item = spanned<meta_item_>;
 #[auto_decode]
 #[deriving_eq]
 pub enum meta_item_ {
-    meta_word(~str),
+    meta_word(@~str),
-    meta_list(~str, ~[@meta_item]),
+    meta_list(@~str, ~[@meta_item]),
-    meta_name_value(~str, lit),
+    meta_name_value(@~str, lit),
 }
 
 pub type blk = spanned<blk_>;

src/libsyntax/attr.rs

@@ -37,16 +37,16 @@ pub fn mk_name_value_item_str(name: @~str, value: @~str)
 
 pub fn mk_name_value_item(name: @~str, +value: ast::lit)
         -> @ast::meta_item {
-    @dummy_spanned(ast::meta_name_value(/*bad*/ copy *name, value))
+    @dummy_spanned(ast::meta_name_value(name, value))
 }
 
 pub fn mk_list_item(name: @~str, +items: ~[@ast::meta_item]) ->
    @ast::meta_item {
-    @dummy_spanned(ast::meta_list(/*bad*/ copy *name, items))
+    @dummy_spanned(ast::meta_list(name, items))
 }
 
 pub fn mk_word_item(name: @~str) -> @ast::meta_item {
-    @dummy_spanned(ast::meta_word(/*bad*/ copy *name))
+    @dummy_spanned(ast::meta_word(name))
 }
 
 pub fn mk_attr(item: @ast::meta_item) -> ast::attribute {
@@ -60,7 +60,7 @@ pub fn mk_sugared_doc_attr(text: ~str,
     let lit = spanned(lo, hi, ast::lit_str(@text));
     let attr = ast::attribute_ {
         style: doc_comment_style(text),
-        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)
@@ -96,9 +96,9 @@ pub pure fn get_attr_name(attr: &ast::attribute) -> @~str {
 
 pub pure fn get_meta_item_name(meta: @ast::meta_item) -> @~str {
     match meta.node {
-        ast::meta_word(ref n) => @/*bad*/ copy *n,
+        ast::meta_word(n) => n,
-        ast::meta_name_value(ref n, _) => @/*bad*/ copy *n,
+        ast::meta_name_value(n, _) => n,
-        ast::meta_list(ref n, _) => @/*bad*/ copy *n,
+        ast::meta_list(n, _) => n,
     }
 }
 
@@ -343,8 +343,8 @@ pub fn find_inline_attr(attrs: &[ast::attribute]) -> inline_attr {
     // FIXME (#2809)---validate the usage of #[inline] and #[inline(always)]
     do vec::foldl(ia_none, attrs) |ia,attr| {
         match attr.node.value.node {
-          ast::meta_word(~"inline") => ia_hint,
+          ast::meta_word(@~"inline") => ia_hint,
-          ast::meta_list(~"inline", items) => {
+          ast::meta_list(@~"inline", items) => {
             if !vec::is_empty(find_meta_items_by_name(items, ~"always")) {
                 ia_always
             } else if !vec::is_empty(

src/libsyntax/ext/pipes/ast_builder.rs

@@ -228,9 +228,10 @@ pub impl ext_ctxt_ast_builder for ext_ctxt {
         let non_camel_case_attribute = respan(dummy_sp(), ast::attribute_ {
             style: ast::attr_outer,
             value: respan(dummy_sp(),
-                          ast::meta_list(~"allow", ~[
+                          ast::meta_list(@~"allow", ~[
                               @respan(dummy_sp(),
-                                      ast::meta_word(~"non_camel_case_types"))
+                                      ast::meta_word(
+                                         @~"non_camel_case_types"))
                           ])),
             is_sugared_doc: false
         });

src/libsyntax/parse/attr.rs

@@ -126,22 +126,22 @@ impl parser_attr for Parser {
 
     fn parse_meta_item() -> @ast::meta_item {
         let lo = self.span.lo;
-        let name = *self.id_to_str(self.parse_ident());
+        let name = self.id_to_str(self.parse_ident());
         match self.token {
             token::EQ => {
                 self.bump();
                 let lit = self.parse_lit();
                 let mut hi = self.span.hi;
-            return @spanned(lo, hi, ast::meta_name_value(name, lit));
+                @spanned(lo, hi, ast::meta_name_value(name, lit))
             }
             token::LPAREN => {
                 let inner_items = self.parse_meta_seq();
                 let mut hi = self.span.hi;
-            return @spanned(lo, hi, ast::meta_list(name, inner_items));
+                @spanned(lo, hi, ast::meta_list(name, inner_items))
             }
             _ => {
                 let mut hi = self.span.hi;
-            return @spanned(lo, hi, ast::meta_word(name));
+                @spanned(lo, hi, ast::meta_word(name))
             }
         }
     }

src/libsyntax/print/pprust.rs

@@ -1816,13 +1816,13 @@ pub fn print_type_params(s: @ps, &&params: ~[ast::ty_param]) {
 pub fn print_meta_item(s: @ps, &&item: @ast::meta_item) {
     ibox(s, indent_unit);
     match item.node {
-      ast::meta_word(ref name) => word(s.s, *name),
+      ast::meta_word(name) => word(s.s, *name),
-      ast::meta_name_value(ref name, value) => {
+      ast::meta_name_value(name, value) => {
         word_space(s, *name);
         word_space(s, ~"=");
         print_literal(s, @value);
       }
-      ast::meta_list(ref name, ref items) => {
+      ast::meta_list(name, ref items) => {
         word(s.s, *name);
         popen(s);
         commasep(