libsyntax: add some more explicit copies

2 files changed, 139 insertions, 79 deletions

diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index cf5cb847018..d8c3ca06d76 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -81,78 +81,116 @@ pub fn new_parse_sess_special_handler(sh: span_handler, cm: @codemap::CodeMap)
 
 // this appears to be the main entry point for rust parsing by
 // rustc and crate:
-pub fn parse_crate_from_file(input: &Path, cfg: ast::crate_cfg,
-                         sess: @mut ParseSess) -> @ast::crate {
-    let p = new_parser_from_file(sess, cfg, input);
-    p.parse_crate_mod(cfg)
+pub fn parse_crate_from_file(
+    input: &Path,
+    cfg: ast::crate_cfg,
+    sess: @mut ParseSess
+) -> @ast::crate {
+    let p = new_parser_from_file(sess, /*bad*/ copy cfg, input);
+    p.parse_crate_mod(/*bad*/ copy cfg)
     // why is there no p.abort_if_errors here?
 }
 
-pub fn parse_crate_from_source_str(name: ~str,
-                                   source: @~str,
-                                   cfg: ast::crate_cfg,
-                                   sess: @mut ParseSess) -> @ast::crate {
-    let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
-                                       codemap::FssNone, source);
-    let r = p.parse_crate_mod(cfg);
+pub fn parse_crate_from_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,
+        codemap::FssNone,
+        source
+    );
+    let r = p.parse_crate_mod(/*bad*/ copy cfg);
     p.abort_if_errors();
-    return r;
+    r
 }
 
-pub fn parse_expr_from_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,
-                                       codemap::FssNone, source);
+pub fn parse_expr_from_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,
+        codemap::FssNone,
+        source
+    );
     let r = p.parse_expr();
     p.abort_if_errors();
-    return r;
+    r
 }
 
-pub fn parse_item_from_source_str(name: ~str,
-                                  source: @~str,
-                                  cfg: ast::crate_cfg,
-                                  +attrs: ~[ast::attribute],
-                                  sess: @mut ParseSess)
-                               -> Option<@ast::item> {
-    let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
-                                       codemap::FssNone, source);
+pub fn parse_item_from_source_str(
+    name: ~str,
+    source: @~str,
+    +cfg: ast::crate_cfg,
+    +attrs: ~[ast::attribute],
+    sess: @mut ParseSess
+) -> Option<@ast::item> {
+    let p = new_parser_from_source_str(
+        sess,
+        cfg,
+        /*bad*/ copy name,
+        codemap::FssNone,
+        source
+    );
     let r = p.parse_item(attrs);
     p.abort_if_errors();
-    return r;
+    r
 }
 
-pub fn parse_stmt_from_source_str(name: ~str,
-                                  source: @~str,
-                                  cfg: ast::crate_cfg,
-                                  +attrs: ~[ast::attribute],
-                                  sess: @mut ParseSess) -> @ast::stmt {
-    let p = new_parser_from_source_str(sess, cfg, /*bad*/ copy name,
-                                       codemap::FssNone, source);
+pub fn parse_stmt_from_source_str(
+    name: ~str,
+    source: @~str,
+    +cfg: ast::crate_cfg,
+    +attrs: ~[ast::attribute],
+    sess: @mut ParseSess
+) -> @ast::stmt {
+    let p = new_parser_from_source_str(
+        sess,
+        cfg,
+        /*bad*/ copy name,
+        codemap::FssNone,
+        source
+    );
     let r = p.parse_stmt(attrs);
     p.abort_if_errors();
-    return r;
+    r
 }
 
-pub fn parse_tts_from_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,
-                                       codemap::FssNone, source);
+pub fn parse_tts_from_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,
+        codemap::FssNone,
+        source
+    );
     *p.quote_depth += 1u;
     let r = p.parse_all_token_trees();
     p.abort_if_errors();
-    return r;
+    r
 }
 
-pub fn parse_from_source_str<T>(f: fn (p: Parser) -> T,
-                            name: ~str, ss: codemap::FileSubstr,
-                            source: @~str, cfg: ast::crate_cfg,
-                            sess: @mut ParseSess)
-    -> T
-{
+pub fn parse_from_source_str<T>(
+    f: fn (Parser) -> T,
+    name: ~str, ss: codemap::FileSubstr,
+    source: @~str,
+    +cfg: ast::crate_cfg,
+    sess: @mut ParseSess
+) -> T {
     let p = new_parser_from_source_str(
         sess,
         cfg,
@@ -176,40 +214,51 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
     return rv;
 }
 
-pub fn new_parser_from_source_str(sess: @mut ParseSess, cfg: ast::crate_cfg,
-                              +name: ~str, +ss: codemap::FileSubstr,
-                              source: @~str) -> Parser {
+pub fn new_parser_from_source_str(
+    sess: @mut ParseSess,
+    +cfg: ast::crate_cfg,
+    +name: ~str,
+    +ss: codemap::FileSubstr,
+    source: @~str
+) -> Parser {
     let filemap = sess.cm.new_filemap_w_substr(name, ss, source);
-    let srdr = lexer::new_string_reader(copy sess.span_diagnostic,
-                                        filemap,
-                                        sess.interner);
-    return Parser(sess, cfg, srdr as reader);
+    let srdr = lexer::new_string_reader(
+        copy sess.span_diagnostic,
+        filemap,
+        sess.interner
+    );
+    Parser(sess, cfg, srdr as reader)
 }
 
 // Read the entire source file, return a parser
 // that draws from that string
-pub fn new_parser_result_from_file(sess: @mut ParseSess,
-                            cfg: ast::crate_cfg,
-                            path: &Path)
-                         -> Result<Parser, ~str> {
+pub fn new_parser_result_from_file(
+    sess: @mut ParseSess,
+    +cfg: ast::crate_cfg,
+    path: &Path
+) -> Result<Parser, ~str> {
     match io::read_whole_file_str(path) {
-      result::Ok(src) => {
-
-          let filemap = sess.cm.new_filemap(path.to_str(), @src);
-          let srdr = lexer::new_string_reader(copy sess.span_diagnostic,
-                                              filemap,
-                                              sess.interner);
-          Ok(Parser(sess, cfg, srdr as reader))
+        Ok(src) => {
+            let filemap = sess.cm.new_filemap(path.to_str(), @src);
+            let srdr = lexer::new_string_reader(
+                copy sess.span_diagnostic,
+                filemap,
+                sess.interner
+            );
+            Ok(Parser(sess, cfg, srdr as reader))
 
-      }
-      result::Err(e) => Err(e)
+        }
+        Err(e) => Err(e)
     }
 }
 
 /// Create a new parser for an entire crate, handling errors as appropriate
 /// if the file doesn't exist
-pub fn new_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
-                              path: &Path) -> Parser {
+pub fn new_parser_from_file(
+    sess: @mut ParseSess,
+    +cfg: ast::crate_cfg,
+    path: &Path
+) -> Parser {
     match new_parser_result_from_file(sess, cfg, path) {
         Ok(parser) => parser,
         Err(e) => {
@@ -220,8 +269,12 @@ pub fn new_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
 
 /// Create a new parser based on a span from an existing parser. Handles
 /// error messages correctly when the file does not exist.
-pub fn new_sub_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
-                            path: &Path, sp: span) -> Parser {
+pub fn new_sub_parser_from_file(
+    sess: @mut ParseSess,
+    +cfg: ast::crate_cfg,
+    path: &Path,
+    sp: span
+) -> Parser {
     match new_parser_result_from_file(sess, cfg, path) {
         Ok(parser) => parser,
         Err(e) => {
@@ -230,11 +283,18 @@ pub fn new_sub_parser_from_file(sess: @mut ParseSess, cfg: ast::crate_cfg,
     }
 }
 
-pub fn new_parser_from_tts(sess: @mut ParseSess, cfg: ast::crate_cfg,
-                           +tts: ~[ast::token_tree]) -> Parser {
-    let trdr = lexer::new_tt_reader(copy sess.span_diagnostic, sess.interner,
-                                    None, tts);
-    return Parser(sess, cfg, trdr as reader)
+pub fn new_parser_from_tts(
+    sess: @mut ParseSess,
+    +cfg: ast::crate_cfg,
+    +tts: ~[ast::token_tree]
+) -> Parser {
+    let trdr = lexer::new_tt_reader(
+        copy sess.span_diagnostic,
+        sess.interner,
+        None,
+        tts
+    );
+    Parser(sess, cfg, trdr as reader)
 }
 
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2c7947090c2..dffa04ac1ca 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3492,7 +3492,7 @@ pub impl Parser {
         };
         let full_path = full_path.normalize();
         let p0 =
-            new_sub_parser_from_file(self.sess, self.cfg,
+            new_sub_parser_from_file(self.sess, copy self.cfg,
                                      &full_path, id_sp);
         let (inner, next) = p0.parse_inner_attrs_and_next();
         let mod_attrs = vec::append(