syntax: Remove several deep copies that were happening due to misuse of parse_seq

2 files changed, 90 insertions, 76 deletions

diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index c0a2f9b9e6e..0c2718c3b4b 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -209,9 +209,16 @@ impl parser_common for parser {
         ret v;
     }
 
-    // FIXME: A lot of callers go through here, only to copy out the T and
-    // discard the spanned<> wrapper. I feel as though there should be a
-    // version of this that does not return a spanned result.
+    fn parse_unspanned_seq<T: copy>(bra: token::token, ket: token::token,
+                                    sep: seq_sep, f: fn(parser) -> T) -> [T] {
+        self.expect(bra);
+        let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
+        self.bump();
+        ret result;
+    }
+
+    // NB: Do not use this function unless you actually plan to place the
+    // spanned list in the AST.
     fn parse_seq<T: copy>(bra: token::token, ket: token::token, sep: seq_sep,
                           f: fn(parser) -> T) -> spanned<[T]> {
         let lo = self.span.lo;
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 33e7d082bfb..df27b2388e0 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -150,8 +150,8 @@ class parser {
 
     fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
         let inputs =
-            self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA)) { |p|
+            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                     seq_sep(token::COMMA)) { |p|
             let mode = p.parse_arg_mode();
             let name = if is_plain_ident(p.token)
                 && p.look_ahead(1u) == token::COLON {
@@ -170,13 +170,14 @@ class parser {
         // story on constrained types.
         let constrs: [@constr] = [];
         let (ret_style, ret_ty) = self.parse_ret_ty();
-        ret {inputs: inputs.node, output: ret_ty,
+        ret {inputs: inputs, output: ret_ty,
              purity: purity, cf: ret_style,
              constraints: constrs};
     }
 
     fn parse_ty_methods() -> [ty_method] {
-        (self.parse_seq(token::LBRACE, token::RBRACE, seq_sep_none()) { |p|
+        self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
+                                 seq_sep_none()) { |p|
             let attrs = p.parse_outer_attributes();
             let flo = p.span.lo;
             let pur = p.parse_fn_purity();
@@ -186,7 +187,7 @@ class parser {
             self.expect(token::SEMI);
             {ident: ident, attrs: attrs, decl: {purity: pur with d}, tps: tps,
              span: mk_sp(flo, fhi)}
-        }).node
+        }
     }
 
     fn parse_mt() -> mt {
@@ -241,21 +242,21 @@ class parser {
     fn parse_ty_constr(fn_args: [arg]) -> @constr {
         let lo = self.span.lo;
         let path = self.parse_path_without_tps();
-        let args: {node: [@constr_arg], span: span} =
-            self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA),
-                           {|p| p.parse_constr_arg(fn_args)});
-        ret @spanned(lo, args.span.hi,
-                     {path: path, args: args.node, id: self.get_id()});
+        let args =
+            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                     seq_sep(token::COMMA),
+                                     {|p| p.parse_constr_arg(fn_args)});
+        ret @spanned(lo, self.span.hi,
+                     {path: path, args: args, id: self.get_id()});
     }
 
     fn parse_constr_in_type() -> @ty_constr {
         let lo = self.span.lo;
         let path = self.parse_path_without_tps();
         let args: [@ty_constr_arg] =
-            self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA),
-                           {|p| p.parse_type_constr_arg()}).node;
+            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                     seq_sep(token::COMMA),
+                                     {|p| p.parse_type_constr_arg()});
         let hi = self.span.lo;
         let tc: ty_constr_ = {path: path, args: args, id: self.get_id()};
         ret @spanned(lo, hi, tc);
@@ -370,15 +371,15 @@ class parser {
             self.bump();
             ty_ptr(self.parse_mt())
         } else if self.token == token::LBRACE {
-            let elems = self.parse_seq(token::LBRACE, token::RBRACE,
-                                       seq_sep_opt(token::COMMA),
-                                       {|p| p.parse_ty_field()});
-            if vec::len(elems.node) == 0u {
+            let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
+                                                 seq_sep_opt(token::COMMA),
+                                                 {|p| p.parse_ty_field()});
+            if vec::len(elems) == 0u {
                 self.unexpected_last(token::RBRACE);
             }
-            let hi = elems.span.hi;
+            let hi = self.span.hi;
 
-            let t = ty_rec(elems.node);
+            let t = ty_rec(elems);
             if self.token == token::COLON {
                 self.bump();
                 ty_constr(@{id: self.get_id(),
@@ -813,11 +814,11 @@ class parser {
             ex = ex_ext.node;
         } else if self.eat_keyword("bind") {
             let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
-            let es = self.parse_seq(token::LPAREN, token::RPAREN,
-                                    seq_sep(token::COMMA),
-                                    {|p| p.parse_expr_or_hole()});
-            hi = es.span.hi;
-            ex = expr_bind(e, es.node);
+            let es = self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                              seq_sep(token::COMMA),
+                                              {|p| p.parse_expr_or_hole()});
+            hi = self.span.hi;
+            ex = expr_bind(e, es);
         } else if self.eat_keyword("fail") {
             if can_begin_expr(self.token) {
                 let e = self.parse_expr();
@@ -920,37 +921,37 @@ class parser {
         let sep = seq_sep(token::COMMA);
         let mut e = none;
         if (self.token == token::LPAREN || self.token == token::LBRACKET) {
+            let lo = self.span.lo;
             let es =
                 if self.token == token::LPAREN {
-                self.parse_seq(token::LPAREN, token::RPAREN,
-                               sep, {|p| p.parse_expr()})
-        } else {
-            self.parse_seq(token::LBRACKET, token::RBRACKET,
-                           sep, {|p| p.parse_expr()})
-        };
-        let hi = es.span.hi;
-        e = some(self.mk_expr(es.span.lo, hi,
-                              expr_vec(es.node, m_imm)));
-    }
-    let mut b = none;
-    if self.token == token::LBRACE {
-        self.bump();
-        let lo = self.span.lo;
-        let mut depth = 1u;
-        while (depth > 0u) {
-            alt (self.token) {
-              token::LBRACE {depth += 1u;}
-              token::RBRACE {depth -= 1u;}
-              token::EOF {self.fatal("unexpected EOF in macro body");}
-              _ {}
-            }
+                    self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                             sep, {|p| p.parse_expr()})
+                } else {
+                    self.parse_unspanned_seq(token::LBRACKET, token::RBRACKET,
+                                             sep, {|p| p.parse_expr()})
+                };
+            let hi = self.span.hi;
+            e = some(self.mk_expr(lo, hi, expr_vec(es, m_imm)));
+        }
+        let mut b = none;
+        if self.token == token::LBRACE {
             self.bump();
+            let lo = self.span.lo;
+            let mut depth = 1u;
+            while (depth > 0u) {
+                alt (self.token) {
+                  token::LBRACE {depth += 1u;}
+                  token::RBRACE {depth -= 1u;}
+                  token::EOF {self.fatal("unexpected EOF in macro body");}
+                  _ {}
+                }
+                self.bump();
+            }
+            let hi = self.last_span.lo;
+            b = some({span: mk_sp(lo,hi)});
         }
-        let hi = self.last_span.lo;
-        b = some({span: mk_sp(lo,hi)});
+        ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b));
     }
-    ret self.mk_mac_expr(lo, self.span.hi, mac_invoc(pth, e, b));
-}
 
     fn parse_dot_or_call_expr() -> pexpr {
         let b = self.parse_bottom_expr();
@@ -989,16 +990,17 @@ class parser {
             alt copy self.token {
               // expr(...)
               token::LPAREN if self.permits_call() {
-                let es_opt = self.parse_seq(token::LPAREN, token::RPAREN,
-                                            seq_sep(token::COMMA),
-                                            {|p| p.parse_expr_or_hole()});
-                hi = es_opt.span.hi;
+                let es_opt =
+                    self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                             seq_sep(token::COMMA),
+                                             {|p| p.parse_expr_or_hole()});
+                hi = self.span.hi;
 
                 let nd =
-                    if vec::any(es_opt.node, {|e| option::is_none(e) }) {
-                    expr_bind(self.to_expr(e), es_opt.node)
+                    if vec::any(es_opt, {|e| option::is_none(e) }) {
+                    expr_bind(self.to_expr(e), es_opt)
             } else {
-                let es = vec::map(es_opt.node) {|e| option::get(e) };
+                let es = vec::map(es_opt) {|e| option::get(e) };
                 expr_call(self.to_expr(e), es, false)
             };
             e = self.mk_pexpr(lo, hi, nd);
@@ -1458,11 +1460,12 @@ class parser {
                         self.expect(token::RPAREN);
                       }
                       _ {
-                        let a = self.parse_seq(token::LPAREN, token::RPAREN,
-                                               seq_sep(token::COMMA),
-                                               {|p| p.parse_pat()});
-                        args = a.node;
-                        hi = a.span.hi;
+                        args =
+                            self.parse_unspanned_seq(token::LPAREN,
+                                                     token::RPAREN,
+                                                     seq_sep(token::COMMA),
+                                                     {|p| p.parse_pat()});
+                        hi = self.span.hi;
                       }
                     }
                   }
@@ -1761,8 +1764,8 @@ class parser {
         -> (fn_decl, capture_clause) {
 
         let args_or_capture_items: [arg_or_capture_item] =
-            self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA), parse_arg_fn).node;
+            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
+                                     seq_sep(token::COMMA), parse_arg_fn);
 
         let inputs = either::lefts(args_or_capture_items);
         let capture_clause = @either::rights(args_or_capture_items);
@@ -1788,9 +1791,10 @@ class parser {
             if self.eat(token::OROR) {
                 []
             } else {
-                self.parse_seq(token::BINOP(token::OR),
-                               token::BINOP(token::OR), seq_sep(token::COMMA),
-                               {|p| p.parse_fn_block_arg()}).node
+                self.parse_unspanned_seq(token::BINOP(token::OR),
+                                         token::BINOP(token::OR),
+                                         seq_sep(token::COMMA),
+                                         {|p| p.parse_fn_block_arg()})
             }
         };
         let output = if self.eat(token::RARROW) {
@@ -2242,10 +2246,12 @@ class parser {
             let mut args = [], disr_expr = none;
             if self.token == token::LPAREN {
                 all_nullary = false;
-                let arg_tys = self.parse_seq(token::LPAREN, token::RPAREN,
+                let arg_tys =
+                    self.parse_unspanned_seq(token::LPAREN,
+                                             token::RPAREN,
                                              seq_sep(token::COMMA),
                                              {|p| p.parse_ty(false)});
-                for arg_tys.node.each {|ty|
+                for arg_tys.each {|ty|
                     args += [{ty: ty, id: self.get_id()}];
                 }
             } else if self.eat(token::EQ) {
@@ -2385,9 +2391,10 @@ class parser {
                   // foo::bar::{a,b,c}
                   token::LBRACE {
                     let idents =
-                        self.parse_seq(token::LBRACE, token::RBRACE,
-                                       seq_sep(token::COMMA),
-                                       {|p| p.parse_path_list_ident()}).node;
+                        self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
+                                                 seq_sep(token::COMMA),
+                                                 {|p|
+                                                  p.parse_path_list_ident()});
                     let path = @{span: mk_sp(lo, self.span.hi),
                                  global: false, idents: path,
                                  rp: none, types: []};