bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

syntax: clarify that trailing separators are never required

Browse source
This commit is contained in:
Lindsey Kuper 2012-06-12 10:17:36 -07:00
parent d04ed0c493
commit bffb7db8ae
3 changed files with 60 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/libsyntax/parse/attr.rs
View file

@ -1,6 +1,6 @@
import either::{either, left, right}; import either::{either, left, right};
import ast_util::spanned; import ast_util::spanned;
import common::{parser_common, seq_sep}; import common::{parser_common, seq_sep_trailing_disallowed};
export attr_or_ext; export attr_or_ext;
export parser_attr; export parser_attr;
@ -111,7 +111,7 @@ impl parser_attr for parser {
fn parse_meta_seq() -> [@ast::meta_item] { fn parse_meta_seq() -> [@ast::meta_item] {
ret self.parse_seq(token::LPAREN, token::RPAREN, ret self.parse_seq(token::LPAREN, token::RPAREN,
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_meta_item()}).node; {|p| p.parse_meta_item()}).node;
} }

16
src/libsyntax/parse/common.rs
View file

@ -4,25 +4,23 @@ import parser::parser;
type seq_sep = { type seq_sep = {
sep: option<token::token>, sep: option<token::token>,
trailing_opt: bool // is trailing separator optional? trailing_sep_allowed: bool
}; };
fn seq_sep(t: token::token) -> seq_sep { fn seq_sep_trailing_disallowed(t: token::token) -> seq_sep {
ret {sep: option::some(t), trailing_opt: false}; ret {sep: option::some(t), trailing_sep_allowed: false};
} }
fn seq_sep_opt(t: token::token) -> seq_sep { fn seq_sep_trailing_allowed(t: token::token) -> seq_sep {
ret {sep: option::some(t), trailing_opt: true}; ret {sep: option::some(t), trailing_sep_allowed: true};
} }
fn seq_sep_none() -> seq_sep { 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 { fn token_to_str(reader: reader, ++token: token::token) -> str {
token::to_str(*reader.interner, token) token::to_str(*reader.interner, token)
} }
// This should be done with traits, once traits work // This should be done with traits, once traits work
impl parser_common for parser { impl parser_common for parser {
@ -203,7 +201,7 @@ impl parser_common for parser {
else { self.expect(t); } } else { self.expect(t); } }
_ { } _ { }
} }
if sep.trailing_opt && self.token == ket { break; } if sep.trailing_sep_allowed && self.token == ket { break; }
v += [f(self)]; v += [f(self)];
} }
ret v; ret v;

100
src/libsyntax/parse/parser.rs
View file

@ -9,7 +9,8 @@ import ast::*;
import lexer::reader; import lexer::reader;
import prec::{as_prec, token_to_binop}; import prec::{as_prec, token_to_binop};
import attr::parser_attr; 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 common::*;//{parser_common};
import dvec::{dvec, extensions}; import dvec::{dvec, extensions};
@ -167,9 +168,9 @@ class parser {
} }
fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl { fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
let inputs = let inputs = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::RPAREN, token::LPAREN, token::RPAREN,
seq_sep(token::COMMA)) { |p| seq_sep_trailing_disallowed(token::COMMA)) { |p|
let mode = p.parse_arg_mode(); let mode = p.parse_arg_mode();
let name = if is_plain_ident(p.token) let name = if is_plain_ident(p.token)
&& p.look_ahead(1u) == token::COLON { && p.look_ahead(1u) == token::COLON {
@ -260,10 +261,10 @@ class parser {
fn parse_ty_constr(fn_args: [arg]) -> @constr { fn parse_ty_constr(fn_args: [arg]) -> @constr {
let lo = self.span.lo; let lo = self.span.lo;
let path = self.parse_path_without_tps(); let path = self.parse_path_without_tps();
let args = let args = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::RPAREN, token::LPAREN, token::RPAREN,
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_constr_arg(fn_args)}); {|p| p.parse_constr_arg(fn_args)});
ret @spanned(lo, self.span.hi, ret @spanned(lo, self.span.hi,
{path: path, args: args, id: self.get_id()}); {path: path, args: args, id: self.get_id()});
} }
@ -271,10 +272,10 @@ class parser {
fn parse_constr_in_type() -> @ty_constr { fn parse_constr_in_type() -> @ty_constr {
let lo = self.span.lo; let lo = self.span.lo;
let path = self.parse_path_without_tps(); let path = self.parse_path_without_tps();
let args: [@ty_constr_arg] = let args: [@ty_constr_arg] = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::RPAREN, token::LPAREN, token::RPAREN,
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_type_constr_arg()}); {|p| p.parse_type_constr_arg()});
let hi = self.span.lo; let hi = self.span.lo;
let tc: ty_constr_ = {path: path, args: args, id: self.get_id()}; let tc: ty_constr_ = {path: path, args: args, id: self.get_id()};
ret @spanned(lo, hi, tc); ret @spanned(lo, hi, tc);
@ -389,9 +390,10 @@ class parser {
self.bump(); self.bump();
ty_ptr(self.parse_mt()) ty_ptr(self.parse_mt())
} else if self.token == token::LBRACE { } else if self.token == token::LBRACE {
let elems = self.parse_unspanned_seq(token::LBRACE, token::RBRACE, let elems = self.parse_unspanned_seq(
seq_sep_opt(token::COMMA), token::LBRACE, token::RBRACE,
{|p| p.parse_ty_field()}); seq_sep_trailing_allowed(token::COMMA),
{|p| p.parse_ty_field()});
if vec::len(elems) == 0u { if vec::len(elems) == 0u {
self.unexpected_last(token::RBRACE); self.unexpected_last(token::RBRACE);
} }
@ -802,9 +804,9 @@ class parser {
} else if self.token == token::LBRACKET { } else if self.token == token::LBRACKET {
self.bump(); self.bump();
let mutbl = self.parse_mutability(); let mutbl = self.parse_mutability();
let es = let es = self.parse_seq_to_end(
self.parse_seq_to_end(token::RBRACKET, seq_sep(token::COMMA), token::RBRACKET, seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_expr()}); {|p| p.parse_expr()});
hi = self.span.hi; hi = self.span.hi;
ex = expr_vec(es, mutbl); ex = expr_vec(es, mutbl);
} else if self.token == token::POUND } else if self.token == token::POUND
@ -833,9 +835,10 @@ class parser {
ex = ex_ext.node; ex = ex_ext.node;
} else if self.eat_keyword("bind") { } else if self.eat_keyword("bind") {
let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS); let e = self.parse_expr_res(RESTRICT_NO_CALL_EXPRS);
let es = self.parse_unspanned_seq(token::LPAREN, token::RPAREN, let es = self.parse_unspanned_seq(
seq_sep(token::COMMA), token::LPAREN, token::RPAREN,
{|p| p.parse_expr_or_hole()}); seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_expr_or_hole()});
hi = self.span.hi; hi = self.span.hi;
ex = expr_bind(e, es); ex = expr_bind(e, es);
} else if self.eat_keyword("fail") { } else if self.eat_keyword("fail") {
@ -937,7 +940,7 @@ class parser {
} }
let pth = self.parse_path_without_tps(); let pth = self.parse_path_without_tps();
//temporary for a backwards-compatible cycle: //temporary for a backwards-compatible cycle:
let sep = seq_sep(token::COMMA); let sep = seq_sep_trailing_disallowed(token::COMMA);
let mut e = none; let mut e = none;
if (self.token == token::LPAREN || self.token == token::LBRACKET) { if (self.token == token::LPAREN || self.token == token::LBRACKET) {
let lo = self.span.lo; let lo = self.span.lo;
@ -1009,10 +1012,10 @@ class parser {
alt copy self.token { alt copy self.token {
// expr(...) // expr(...)
token::LPAREN if self.permits_call() { token::LPAREN if self.permits_call() {
let es_opt = let es_opt = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::RPAREN, token::LPAREN, token::RPAREN,
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_expr_or_hole()}); {|p| p.parse_expr_or_hole()});
hi = self.span.hi; hi = self.span.hi;
let nd = let nd =
@ -1479,11 +1482,10 @@ class parser {
self.expect(token::RPAREN); self.expect(token::RPAREN);
} }
_ { _ {
args = args = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::LPAREN, token::RPAREN,
token::RPAREN, seq_sep_trailing_disallowed(token::COMMA),
seq_sep(token::COMMA), {|p| p.parse_pat()});
{|p| p.parse_pat()});
hi = self.span.hi; hi = self.span.hi;
} }
} }
@ -1783,8 +1785,9 @@ class parser {
-> (fn_decl, capture_clause) { -> (fn_decl, capture_clause) {
let args_or_capture_items: [arg_or_capture_item] = let args_or_capture_items: [arg_or_capture_item] =
self.parse_unspanned_seq(token::LPAREN, token::RPAREN, self.parse_unspanned_seq(
seq_sep(token::COMMA), parse_arg_fn); token::LPAREN, token::RPAREN,
seq_sep_trailing_disallowed(token::COMMA), parse_arg_fn);
let inputs = either::lefts(args_or_capture_items); let inputs = either::lefts(args_or_capture_items);
let capture_clause = @either::rights(args_or_capture_items); let capture_clause = @either::rights(args_or_capture_items);
@ -1810,10 +1813,10 @@ class parser {
if self.eat(token::OROR) { if self.eat(token::OROR) {
[] []
} else { } else {
self.parse_unspanned_seq(token::BINOP(token::OR), self.parse_unspanned_seq(
token::BINOP(token::OR), token::BINOP(token::OR), token::BINOP(token::OR),
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_fn_block_arg()}) {|p| p.parse_fn_block_arg()})
} }
}; };
let output = if self.eat(token::RARROW) { let output = if self.eat(token::RARROW) {
@ -1984,8 +1987,9 @@ class parser {
} }
fn parse_iface_ref_list() -> [@iface_ref] { fn parse_iface_ref_list() -> [@iface_ref] {
self.parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA), self.parse_seq_to_before_end(
{|p| p.parse_iface_ref()}) token::LBRACE, seq_sep_trailing_disallowed(token::COMMA),
{|p| p.parse_iface_ref()})
} }
fn parse_item_class() -> item_info { fn parse_item_class() -> item_info {
@ -2265,11 +2269,10 @@ class parser {
let mut args = [], disr_expr = none; let mut args = [], disr_expr = none;
if self.token == token::LPAREN { if self.token == token::LPAREN {
all_nullary = false; all_nullary = false;
let arg_tys = let arg_tys = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LPAREN, token::LPAREN, token::RPAREN,
token::RPAREN, seq_sep_trailing_disallowed(token::COMMA),
seq_sep(token::COMMA), {|p| p.parse_ty(false)});
{|p| p.parse_ty(false)});
for arg_tys.each {|ty| for arg_tys.each {|ty|
args += [{ty: ty, id: self.get_id()}]; args += [{ty: ty, id: self.get_id()}];
} }
@ -2409,11 +2412,10 @@ class parser {
// foo::bar::{a,b,c} // foo::bar::{a,b,c}
token::LBRACE { token::LBRACE {
let idents = let idents = self.parse_unspanned_seq(
self.parse_unspanned_seq(token::LBRACE, token::RBRACE, token::LBRACE, token::RBRACE,
seq_sep(token::COMMA), seq_sep_trailing_disallowed(token::COMMA),
{|p| {|p| p.parse_path_list_ident()});
p.parse_path_list_ident()});
let path = @{span: mk_sp(lo, self.span.hi), let path = @{span: mk_sp(lo, self.span.hi),
global: false, idents: path, global: false, idents: path,
rp: none, types: []}; rp: none, types: []};