Skip to content

Commit bffb7db

Browse files
lkuperlkuper
committed
syntax: clarify that trailing separators are never required
1 parent d04ed0c commit bffb7db

File tree

3 files changed

+60
-60
lines changed

3 files changed

+60
-60
lines changed

‎src/libsyntax/parse/attr.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import either::{either, left, right};
22
import ast_util::spanned;
3-
import common::{parser_common, seq_sep};
3+
import common::{parser_common, seq_sep_trailing_disallowed};
44

55
export attr_or_ext;
66
export parser_attr;
@@ -111,7 +111,7 @@ impl parser_attr for parser {
111111

112112
fn parse_meta_seq() -> [@ast::meta_item] {
113113
ret self.parse_seq(token::LPAREN, token::RPAREN,
114-
seq_sep(token::COMMA),
114+
seq_sep_trailing_disallowed(token::COMMA),
115115
{|p| p.parse_meta_item()}).node;
116116
}
117117

‎src/libsyntax/parse/common.rs

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4,25 +4,23 @@ import parser::parser;
44

55
type seq_sep = {
66
sep: option<token::token>,
7-
trailing_opt: bool // is trailing separator optional?
7+
trailing_sep_allowed: bool
88
};
99

10-
fn seq_sep(t: token::token) -> seq_sep {
11-
ret {sep: option::some(t), trailing_opt: false};
10+
fn seq_sep_trailing_disallowed(t: token::token) -> seq_sep {
11+
ret {sep: option::some(t), trailing_sep_allowed: false};
1212
}
13-
fn seq_sep_opt(t: token::token) -> seq_sep {
14-
ret {sep: option::some(t), trailing_opt: true};
13+
fn seq_sep_trailing_allowed(t: token::token) -> seq_sep {
14+
ret {sep: option::some(t), trailing_sep_allowed: true};
1515
}
1616
fn seq_sep_none() -> seq_sep {
17-
ret {sep: option::none, trailing_opt: false};
17+
ret {sep: option::none, trailing_sep_allowed: false};
1818
}
1919

20-
2120
fn token_to_str(reader: reader, ++token: token::token) -> str {
2221
token::to_str(*reader.interner, token)
2322
}
2423

25-
2624
// This should be done with traits, once traits work
2725
impl parser_common for parser {
2826

@@ -203,7 +201,7 @@ impl parser_common for parser {
203201
else { self.expect(t); } }
204202
_ { }
205203
}
206-
if sep.trailing_opt && self.token == ket { break; }
204+
if sep.trailing_sep_allowed && self.token == ket { break; }
207205
v += [f(self)];
208206
}
209207
ret v;

‎src/libsyntax/parse/parser.rs

Lines changed: 51 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,8 @@ import ast::*;
99
import lexer::reader;
1010
import prec::{as_prec, token_to_binop};
1111
import attr::parser_attr;
12-
import common::{seq_sep, seq_sep_opt, seq_sep_none, token_to_str};
12+
import common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed,
13+
seq_sep_none, token_to_str};
1314
import common::*;//{parser_common};
1415
import dvec::{dvec, extensions};
1516

@@ -167,9 +168,9 @@ class parser {
167168
}
168169

169170
fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
170-
let inputs =
171-
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
172-
seq_sep(token::COMMA)) { |p|
171+
let inputs = self.parse_unspanned_seq(
172+
token::LPAREN, token::RPAREN,
173+
seq_sep_trailing_disallowed(token::COMMA)) { |p|
173174
let mode = p.parse_arg_mode();
174175
let name = if is_plain_ident(p.token)
175176
&& p.look_ahead(1u) == token::COLON {
@@ -260,21 +261,21 @@ class parser {
260261
fn parse_ty_constr(fn_args: [arg]) -> @constr {
261262
let lo = self.span.lo;
262263
let path = self.parse_path_without_tps();
263-
let args =
264-
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
265-
seq_sep(token::COMMA),
266-
{|p| p.parse_constr_arg(fn_args)});
264+
let args = self.parse_unspanned_seq(
265+
token::LPAREN, token::RPAREN,
266+
seq_sep_trailing_disallowed(token::COMMA),
267+
{|p| p.parse_constr_arg(fn_args)});
267268
ret @spanned(lo, self.span.hi,
268269
{path: path, args: args, id: self.get_id()});
269270
}
270271

271272
fn parse_constr_in_type() -> @ty_constr {
272273
let lo = self.span.lo;
273274
let path = self.parse_path_without_tps();
274-
let args: [@ty_constr_arg] =
275-
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
276-
seq_sep(token::COMMA),
277-
{|p| p.parse_type_constr_arg()});
275+
let args: [@ty_constr_arg] = self.parse_unspanned_seq(
276+
token::LPAREN, token::RPAREN,
277+
seq_sep_trailing_disallowed(token::COMMA),
278+
{|p| p.parse_type_constr_arg()});
278279
let hi = self.span.lo;
279280
let tc: ty_constr_ = {path: path, args: args, id: self.get_id()};
280281
ret @spanned(lo, hi, tc);
@@ -389,9 +390,10 @@ class parser {
389390
self.bump();
390391
ty_ptr(self.parse_mt())
391392
} else if self.token == token::LBRACE {
392-
let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
393-
seq_sep_opt(token::COMMA),
394-
{|p| p.parse_ty_field()});
393+
let elems = self.parse_unspanned_seq(
394+
token::LBRACE, token::RBRACE,
395+
seq_sep_trailing_allowed(token::COMMA),
396+
{|p| p.parse_ty_field()});
395397
if vec::len(elems) == 0u {
396398
self.unexpected_last(token::RBRACE);
397399
}
@@ -802,9 +804,9 @@ class parser {
802804
} else if self.token == token::LBRACKET {
803805
self.bump();
804806
let mutbl = self.parse_mutability();
805-
let es =
806-
self.parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA),
807-
{|p| p.parse_expr()});
807+
let es = self.parse_seq_to_end(
808+
token::RBRACKET, seq_sep_trailing_disallowed(token::COMMA),
809+
{|p| p.parse_expr()});
808810
hi = self.span.hi;
809811
ex = expr_vec(es, mutbl);
810812
} else if self.token == token::POUND
@@ -833,9 +835,10 @@ class parser {
833835
ex = ex_ext.node;
834836
} else if self.eat_keyword("bind") {
835837
let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
836-
let es = self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
837-
seq_sep(token::COMMA),
838-
{|p| p.parse_expr_or_hole()});
838+
let es = self.parse_unspanned_seq(
839+
token::LPAREN, token::RPAREN,
840+
seq_sep_trailing_disallowed(token::COMMA),
841+
{|p| p.parse_expr_or_hole()});
839842
hi = self.span.hi;
840843
ex = expr_bind(e, es);
841844
} else if self.eat_keyword("fail") {
@@ -937,7 +940,7 @@ class parser {
937940
}
938941
let pth = self.parse_path_without_tps();
939942
//temporary for a backwards-compatible cycle:
940-
let sep = seq_sep(token::COMMA);
943+
let sep = seq_sep_trailing_disallowed(token::COMMA);
941944
let mut e = none;
942945
if (self.token == token::LPAREN || self.token == token::LBRACKET) {
943946
let lo = self.span.lo;
@@ -1009,10 +1012,10 @@ class parser {
10091012
alt copy self.token {
10101013
// expr(...)
10111014
token::LPAREN if self.permits_call() {
1012-
let es_opt =
1013-
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
1014-
seq_sep(token::COMMA),
1015-
{|p| p.parse_expr_or_hole()});
1015+
let es_opt = self.parse_unspanned_seq(
1016+
token::LPAREN, token::RPAREN,
1017+
seq_sep_trailing_disallowed(token::COMMA),
1018+
{|p| p.parse_expr_or_hole()});
10161019
hi = self.span.hi;
10171020

10181021
let nd =
@@ -1479,11 +1482,10 @@ class parser {
14791482
self.expect(token::RPAREN);
14801483
}
14811484
_ {
1482-
args =
1483-
self.parse_unspanned_seq(token::LPAREN,
1484-
token::RPAREN,
1485-
seq_sep(token::COMMA),
1486-
{|p| p.parse_pat()});
1485+
args = self.parse_unspanned_seq(
1486+
token::LPAREN, token::RPAREN,
1487+
seq_sep_trailing_disallowed(token::COMMA),
1488+
{|p| p.parse_pat()});
14871489
hi = self.span.hi;
14881490
}
14891491
}
@@ -1783,8 +1785,9 @@ class parser {
17831785
-> (fn_decl, capture_clause) {
17841786

17851787
let args_or_capture_items: [arg_or_capture_item] =
1786-
self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
1787-
seq_sep(token::COMMA), parse_arg_fn);
1788+
self.parse_unspanned_seq(
1789+
token::LPAREN, token::RPAREN,
1790+
seq_sep_trailing_disallowed(token::COMMA), parse_arg_fn);
17881791

17891792
let inputs = either::lefts(args_or_capture_items);
17901793
let capture_clause = @either::rights(args_or_capture_items);
@@ -1810,10 +1813,10 @@ class parser {
18101813
if self.eat(token::OROR) {
18111814
[]
18121815
} else {
1813-
self.parse_unspanned_seq(token::BINOP(token::OR),
1814-
token::BINOP(token::OR),
1815-
seq_sep(token::COMMA),
1816-
{|p| p.parse_fn_block_arg()})
1816+
self.parse_unspanned_seq(
1817+
token::BINOP(token::OR), token::BINOP(token::OR),
1818+
seq_sep_trailing_disallowed(token::COMMA),
1819+
{|p| p.parse_fn_block_arg()})
18171820
}
18181821
};
18191822
let output = if self.eat(token::RARROW) {
@@ -1984,8 +1987,9 @@ class parser {
19841987
}
19851988

19861989
fn parse_iface_ref_list() -> [@iface_ref] {
1987-
self.parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA),
1988-
{|p| p.parse_iface_ref()})
1990+
self.parse_seq_to_before_end(
1991+
token::LBRACE, seq_sep_trailing_disallowed(token::COMMA),
1992+
{|p| p.parse_iface_ref()})
19891993
}
19901994

19911995
fn parse_item_class() -> item_info {
@@ -2265,11 +2269,10 @@ class parser {
22652269
let mut args = [], disr_expr = none;
22662270
if self.token == token::LPAREN {
22672271
all_nullary = false;
2268-
let arg_tys =
2269-
self.parse_unspanned_seq(token::LPAREN,
2270-
token::RPAREN,
2271-
seq_sep(token::COMMA),
2272-
{|p| p.parse_ty(false)});
2272+
let arg_tys = self.parse_unspanned_seq(
2273+
token::LPAREN, token::RPAREN,
2274+
seq_sep_trailing_disallowed(token::COMMA),
2275+
{|p| p.parse_ty(false)});
22732276
for arg_tys.each {|ty|
22742277
args += [{ty: ty, id: self.get_id()}];
22752278
}
@@ -2409,11 +2412,10 @@ class parser {
24092412

24102413
// foo::bar::{a,b,c}
24112414
token::LBRACE {
2412-
let idents =
2413-
self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
2414-
seq_sep(token::COMMA),
2415-
{|p|
2416-
p.parse_path_list_ident()});
2415+
let idents = self.parse_unspanned_seq(
2416+
token::LBRACE, token::RBRACE,
2417+
seq_sep_trailing_disallowed(token::COMMA),
2418+
{|p| p.parse_path_list_ident()});
24172419
let path = @{span: mk_sp(lo, self.span.hi),
24182420
global: false, idents: path,
24192421
rp: none, types: []};

0 commit comments

Comments
 (0)