syntax: clarify that trailing separators are never required

3 files changed, 60 insertions, 60 deletions

diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index 6615938b9ad..cddf8de479b 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -1,6 +1,6 @@
 import either::{either, left, right};
 import ast_util::spanned;
-import common::{parser_common, seq_sep};
+import common::{parser_common, seq_sep_trailing_disallowed};
 
 export attr_or_ext;
 export parser_attr;
@@ -111,7 +111,7 @@ impl parser_attr for parser {
 
     fn parse_meta_seq() -> [@ast::meta_item] {
         ret self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep(token::COMMA),
+                           seq_sep_trailing_disallowed(token::COMMA),
                            {|p| p.parse_meta_item()}).node;
     }
 
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index 0c2718c3b4b..0520993de74 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -4,25 +4,23 @@ import parser::parser;
 
 type seq_sep = {
     sep: option<token::token>,
-    trailing_opt: bool   // is trailing separator optional?
+    trailing_sep_allowed: bool
 };
 
-fn seq_sep(t: token::token) -> seq_sep {
-    ret {sep: option::some(t), trailing_opt: false};
+fn seq_sep_trailing_disallowed(t: token::token) -> seq_sep {
+    ret {sep: option::some(t), trailing_sep_allowed: false};
 }
-fn seq_sep_opt(t: token::token) -> seq_sep {
-    ret {sep: option::some(t), trailing_opt: true};
+fn seq_sep_trailing_allowed(t: token::token) -> seq_sep {
+    ret {sep: option::some(t), trailing_sep_allowed: true};
 }
 fn seq_sep_none() -> seq_sep {
-    ret {sep: option::none, trailing_opt: false};
+    ret {sep: option::none, trailing_sep_allowed: false};
 }
 
-
 fn token_to_str(reader: reader, ++token: token::token) -> str {
     token::to_str(*reader.interner, token)
 }
 
-
 // This should be done with traits, once traits work
 impl parser_common for parser {
 
@@ -203,7 +201,7 @@ impl parser_common for parser {
                         else { self.expect(t); } }
               _ { }
             }
-            if sep.trailing_opt && self.token == ket { break; }
+            if sep.trailing_sep_allowed && self.token == ket { break; }
             v += [f(self)];
         }
         ret v;
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 7e6fb726f67..33233be3053 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -9,7 +9,8 @@ import ast::*;
 import lexer::reader;
 import prec::{as_prec, token_to_binop};
 import attr::parser_attr;
-import common::{seq_sep, seq_sep_opt, seq_sep_none, token_to_str};
+import common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed,
+                seq_sep_none, token_to_str};
 import common::*;//{parser_common};
 import dvec::{dvec, extensions};
 
@@ -167,9 +168,9 @@ class parser {
     }
 
     fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
-        let inputs =
-            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
-                                     seq_sep(token::COMMA)) { |p|
+        let inputs = self.parse_unspanned_seq(
+            token::LPAREN, token::RPAREN,
+            seq_sep_trailing_disallowed(token::COMMA)) { |p|
             let mode = p.parse_arg_mode();
             let name = if is_plain_ident(p.token)
                 && p.look_ahead(1u) == token::COLON {
@@ -260,10 +261,10 @@ class parser {
     fn parse_ty_constr(fn_args: [arg]) -> @constr {
         let lo = self.span.lo;
         let path = self.parse_path_without_tps();
-        let args =
-            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
-                                     seq_sep(token::COMMA),
-                                     {|p| p.parse_constr_arg(fn_args)});
+        let args = self.parse_unspanned_seq(
+            token::LPAREN, token::RPAREN,
+            seq_sep_trailing_disallowed(token::COMMA),
+            {|p| p.parse_constr_arg(fn_args)});
         ret @spanned(lo, self.span.hi,
                      {path: path, args: args, id: self.get_id()});
     }
@@ -271,10 +272,10 @@ class parser {
     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_unspanned_seq(token::LPAREN, token::RPAREN,
-                                     seq_sep(token::COMMA),
-                                     {|p| p.parse_type_constr_arg()});
+        let args: [@ty_constr_arg] = self.parse_unspanned_seq(
+            token::LPAREN, token::RPAREN,
+            seq_sep_trailing_disallowed(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);
@@ -389,9 +390,10 @@ class parser {
             self.bump();
             ty_ptr(self.parse_mt())
         } else if self.token == token::LBRACE {
-            let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
-                                                 seq_sep_opt(token::COMMA),
-                                                 {|p| p.parse_ty_field()});
+            let elems = self.parse_unspanned_seq(
+                token::LBRACE, token::RBRACE,
+                seq_sep_trailing_allowed(token::COMMA),
+                {|p| p.parse_ty_field()});
             if vec::len(elems) == 0u {
                 self.unexpected_last(token::RBRACE);
             }
@@ -802,9 +804,9 @@ class parser {
         } else if self.token == token::LBRACKET {
             self.bump();
             let mutbl = self.parse_mutability();
-            let es =
-                self.parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA),
-                                      {|p| p.parse_expr()});
+            let es = self.parse_seq_to_end(
+                token::RBRACKET, seq_sep_trailing_disallowed(token::COMMA),
+                {|p| p.parse_expr()});
             hi = self.span.hi;
             ex = expr_vec(es, mutbl);
         } else if self.token == token::POUND
@@ -833,9 +835,10 @@ 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_unspanned_seq(token::LPAREN, token::RPAREN,
-                                              seq_sep(token::COMMA),
-                                              {|p| p.parse_expr_or_hole()});
+            let es = self.parse_unspanned_seq(
+                token::LPAREN, token::RPAREN,
+                seq_sep_trailing_disallowed(token::COMMA),
+                {|p| p.parse_expr_or_hole()});
             hi = self.span.hi;
             ex = expr_bind(e, es);
         } else if self.eat_keyword("fail") {
@@ -937,7 +940,7 @@ class parser {
         }
         let pth = self.parse_path_without_tps();
         //temporary for a backwards-compatible cycle:
-        let sep = seq_sep(token::COMMA);
+        let sep = seq_sep_trailing_disallowed(token::COMMA);
         let mut e = none;
         if (self.token == token::LPAREN || self.token == token::LBRACKET) {
             let lo = self.span.lo;
@@ -1009,10 +1012,10 @@ class parser {
             alt copy self.token {
               // expr(...)
               token::LPAREN if self.permits_call() {
-                let es_opt =
-                    self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
-                                             seq_sep(token::COMMA),
-                                             {|p| p.parse_expr_or_hole()});
+                let es_opt = self.parse_unspanned_seq(
+                    token::LPAREN, token::RPAREN,
+                    seq_sep_trailing_disallowed(token::COMMA),
+                    {|p| p.parse_expr_or_hole()});
                 hi = self.span.hi;
 
                 let nd =
@@ -1479,11 +1482,10 @@ class parser {
                         self.expect(token::RPAREN);
                       }
                       _ {
-                        args =
-                            self.parse_unspanned_seq(token::LPAREN,
-                                                     token::RPAREN,
-                                                     seq_sep(token::COMMA),
-                                                     {|p| p.parse_pat()});
+                        args = self.parse_unspanned_seq(
+                            token::LPAREN, token::RPAREN,
+                            seq_sep_trailing_disallowed(token::COMMA),
+                            {|p| p.parse_pat()});
                         hi = self.span.hi;
                       }
                     }
@@ -1783,8 +1785,9 @@ class parser {
         -> (fn_decl, capture_clause) {
 
         let args_or_capture_items: [arg_or_capture_item] =
-            self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
-                                     seq_sep(token::COMMA), parse_arg_fn);
+            self.parse_unspanned_seq(
+                token::LPAREN, token::RPAREN,
+                seq_sep_trailing_disallowed(token::COMMA), parse_arg_fn);
 
         let inputs = either::lefts(args_or_capture_items);
         let capture_clause = @either::rights(args_or_capture_items);
@@ -1810,10 +1813,10 @@ class parser {
             if self.eat(token::OROR) {
                 []
             } else {
-                self.parse_unspanned_seq(token::BINOP(token::OR),
-                                         token::BINOP(token::OR),
-                                         seq_sep(token::COMMA),
-                                         {|p| p.parse_fn_block_arg()})
+                self.parse_unspanned_seq(
+                    token::BINOP(token::OR), token::BINOP(token::OR),
+                    seq_sep_trailing_disallowed(token::COMMA),
+                    {|p| p.parse_fn_block_arg()})
             }
         };
         let output = if self.eat(token::RARROW) {
@@ -1984,8 +1987,9 @@ class parser {
     }
 
     fn parse_iface_ref_list() -> [@iface_ref] {
-        self.parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA),
-                                     {|p| p.parse_iface_ref()})
+        self.parse_seq_to_before_end(
+            token::LBRACE, seq_sep_trailing_disallowed(token::COMMA),
+            {|p| p.parse_iface_ref()})
     }
 
     fn parse_item_class() -> item_info {
@@ -2265,11 +2269,10 @@ class parser {
             let mut args = [], disr_expr = none;
             if self.token == token::LPAREN {
                 all_nullary = false;
-                let arg_tys =
-                    self.parse_unspanned_seq(token::LPAREN,
-                                             token::RPAREN,
-                                             seq_sep(token::COMMA),
-                                             {|p| p.parse_ty(false)});
+                let arg_tys = self.parse_unspanned_seq(
+                    token::LPAREN, token::RPAREN,
+                    seq_sep_trailing_disallowed(token::COMMA),
+                    {|p| p.parse_ty(false)});
                 for arg_tys.each {|ty|
                     args += [{ty: ty, id: self.get_id()}];
                 }
@@ -2409,11 +2412,10 @@ class parser {
 
                   // foo::bar::{a,b,c}
                   token::LBRACE {
-                    let idents =
-                        self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
-                                                 seq_sep(token::COMMA),
-                                                 {|p|
-                                                  p.parse_path_list_ident()});
+                    let idents = self.parse_unspanned_seq(
+                        token::LBRACE, token::RBRACE,
+                        seq_sep_trailing_disallowed(token::COMMA),
+                        {|p| p.parse_path_list_ident()});
                     let path = @{span: mk_sp(lo, self.span.hi),
                                  global: false, idents: path,
                                  rp: none, types: []};