libsyntax: add some explicit copies

erickt · erickt · commit bff22cf1665e · 2013-02-25T23:37:45.000-08:00
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
@@ -60,8 +60,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) => *itr.get(s),
-          path_name(s) => *itr.get(s)
+          path_mod(s) => copy *itr.get(s),
+          path_name(s) => copy *itr.get(s)
         }
     };
     str::connect(strs, sep)
@@ -70,7 +70,7 @@ 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 vec::is_empty(p) {
         //FIXME /* FIXME (#2543) */ copy *i
-        *itr.get(i)
+        copy *itr.get(i)
     } else {
         fmt!("%s::%s", path_to_str(p, itr), *itr.get(i))
     }
@@ -82,8 +82,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) => *itr.get(s),
-        path_name(s) => *itr.get(s)
+        path_mod(s) => copy *itr.get(s),
+        path_name(s) => copy *itr.get(s)
     }
 }
 
@@ -310,7 +310,10 @@ pub fn map_item(i: @item, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) {
             for methods.each |tm| {
                 let id = ast_util::trait_method_to_ty_method(tm).id;
                 let d_id = ast_util::local_def(i.id);
-                cx.map.insert(id, node_trait_method(@*tm, d_id, item_path));
+                cx.map.insert(
+                    id,
+                    node_trait_method(@copy *tm, d_id, item_path)
+                );
             }
         }
         _ => ()
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
@@ -27,7 +27,7 @@ use core::vec;
 pub pure fn path_name_i(idents: &[ident], intr: @token::ident_interner)
                      -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
-    str::connect(idents.map(|i| *intr.get(*i)), ~"::")
+    str::connect(idents.map(|i| copy *intr.get(*i)), ~"::")
 }
 
 
@@ -283,7 +283,7 @@ pub fn split_trait_methods(trait_methods: &[trait_method])
     let mut reqd = ~[], provd = ~[];
     for trait_methods.each |trt_method| {
         match *trt_method {
-          required(ref tm) => reqd.push((*tm)),
+          required(ref tm) => reqd.push(copy *tm),
           provided(m) => provd.push(m)
         }
     };
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -27,10 +27,14 @@ pub impl proto_parser for parser::Parser {
     fn parse_proto(&self, id: ~str) -> protocol {
         let proto = protocol(id, *self.span);
 
-        self.parse_seq_to_before_end(token::EOF, SeqSep {
-                                        sep: None,
-                                        trailing_sep_allowed: false
-                                     }, |self| self.parse_state(proto));
+        self.parse_seq_to_before_end(
+            token::EOF,
+            SeqSep {
+                sep: None,
+                trailing_sep_allowed: false,
+            },
+            |self| self.parse_state(proto)
+        );
 
         return proto;
     }
@@ -40,9 +44,9 @@ pub impl proto_parser for parser::Parser {
         let name = *self.interner.get(id);
 
         self.expect(&token::COLON);
-        let dir = match *self.token {
-          token::IDENT(n, _) => self.interner.get(n),
-          _ => fail!()
+        let dir = match copy *self.token {
+            token::IDENT(n, _) => self.interner.get(n),
+            _ => fail!()
         };
         self.bump();
         let dir = match dir {
@@ -61,21 +65,29 @@ pub impl proto_parser for parser::Parser {
 
         // parse the messages
         self.parse_unspanned_seq(
-            token::LBRACE, token::RBRACE, SeqSep {
+            token::LBRACE,
+            token::RBRACE,
+            SeqSep {
                 sep: Some(token::COMMA),
-                trailing_sep_allowed: true
-            }, |self| self.parse_message(state));
+                trailing_sep_allowed: true,
+            },
+            |self| self.parse_message(state)
+        );
     }
 
     fn parse_message(&self, state: state) {
         let mname = *self.interner.get(self.parse_ident());
 
         let args = if *self.token == token::LPAREN {
-            self.parse_unspanned_seq(token::LPAREN,
-                                     token::RPAREN, SeqSep {
-                                        sep: Some(token::COMMA),
-                                        trailing_sep_allowed: true
-                                     }, |p| p.parse_ty(false))
+            self.parse_unspanned_seq(
+                token::LPAREN,
+                token::RPAREN,
+                SeqSep {
+                    sep: Some(token::COMMA),
+                    trailing_sep_allowed: true,
+                },
+                |p| p.parse_ty(false)
+            )
         }
         else { ~[] };
 
@@ -85,11 +97,15 @@ pub impl proto_parser for parser::Parser {
           token::IDENT(_, _) => {
             let name = *self.interner.get(self.parse_ident());
             let ntys = if *self.token == token::LT {
-                self.parse_unspanned_seq(token::LT,
-                                         token::GT, SeqSep {
-                                            sep: Some(token::COMMA),
-                                            trailing_sep_allowed: true
-                                         }, |p| p.parse_ty(false))
+                self.parse_unspanned_seq(
+                    token::LT,
+                    token::GT,
+                    SeqSep {
+                        sep: Some(token::COMMA),
+                        trailing_sep_allowed: true,
+                    },
+                    |p| p.parse_ty(false)
+                )
             }
             else { ~[] };
             Some(next_state {state: name, tys: ntys})
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
@@ -424,7 +424,7 @@ pub fn parse_nt(p: Parser, name: ~str) -> nonterminal {
       ~"ident" => match *p.token {
         token::IDENT(sn,b) => { p.bump(); token::nt_ident(sn,b) }
         _ => p.fatal(~"expected ident, found "
-                     + token::to_str(p.reader.interner(), *p.token))
+                     + token::to_str(p.reader.interner(), copy *p.token))
       },
       ~"path" => token::nt_path(p.parse_path_with_tps(false)),
       ~"tt" => {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -280,7 +280,7 @@ pub fn noop_fold_item_underscore(i: &item_, fld: ast_fold) -> item_ {
         }
         item_mac(ref m) => {
             // FIXME #2888: we might actually want to do something here.
-            item_mac((*m))
+            item_mac(copy *m)
         }
     }
 }
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
@@ -27,13 +27,13 @@ pub struct SeqSep {
     trailing_sep_allowed: bool
 }
 
-pub fn seq_sep_trailing_disallowed(t: token::Token) -> SeqSep {
+pub fn seq_sep_trailing_disallowed(+t: token::Token) -> SeqSep {
     SeqSep {
         sep: Some(t),
         trailing_sep_allowed: false,
     }
 }
-pub fn seq_sep_trailing_allowed(t: token::Token) -> SeqSep {
+pub fn seq_sep_trailing_allowed(+t: token::Token) -> SeqSep {
     SeqSep {
         sep: Some(t),
         trailing_sep_allowed: true,
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
@@ -198,7 +198,7 @@ pub impl Parser {
 
     fn try_parse_obsolete_priv_section() -> bool {
         if self.is_keyword(&~"priv") && self.look_ahead(1) == token::LBRACE {
-            self.obsolete(*self.span, ObsoletePrivSection);
+            self.obsolete(copy *self.span, ObsoletePrivSection);
             self.eat_keyword(&~"priv");
             self.bump();
             while *self.token != token::RBRACE {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs

Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,7 @@ pub fn noop_fold_item_underscore(i: &item_, fld: ast_fold) -> item_ {`
`280`	`280`	`}`
`281`	`281`	`item_mac(ref m) => {`
`282`	`282`	`// FIXME #2888: we might actually want to do something here.`
`283`		`- item_mac((*m))`
	`283`	`+ item_mac(copy *m)`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,13 +27,13 @@ pub struct SeqSep {`
`27`	`27`	`trailing_sep_allowed: bool`
`28`	`28`	`}`
`29`	`29`
`30`		`-pub fn seq_sep_trailing_disallowed(t: token::Token) -> SeqSep {`
	`30`	`+pub fn seq_sep_trailing_disallowed(+t: token::Token) -> SeqSep {`
`31`	`31`	`SeqSep {`
`32`	`32`	`sep: Some(t),`
`33`	`33`	`trailing_sep_allowed: false,`
`34`	`34`	`}`
`35`	`35`	`}`
`36`		`-pub fn seq_sep_trailing_allowed(t: token::Token) -> SeqSep {`
	`36`	`+pub fn seq_sep_trailing_allowed(+t: token::Token) -> SeqSep {`
`37`	`37`	`SeqSep {`
`38`	`38`	`sep: Some(t),`
`39`	`39`	`trailing_sep_allowed: true,`