Skip to content

Commit 43b1eab

Browse files
borsbors
committed
auto merge of #7873 : sstewartgallus/rust/cleanup_syntax, r=alexcrichton
2 parents 6dfb0e5 + 9a99f5b commit 43b1eab

File tree

1 file changed

+100
-100
lines changed

1 file changed

+100
-100
lines changed

‎src/libsyntax/parse/parser.rs

+100-100
Original file line numberDiff line numberDiff line change
@@ -406,7 +406,9 @@ impl Parser {
406406
// consume token 'tok' if it exists. Returns true if the given
407407
// token was present, false otherwise.
408408
pub fn eat(&self, tok: &token::Token) -> bool {
409-
return if *self.token == *tok { self.bump(); true } else { false };
409+
let is_present = *self.token == *tok;
410+
if is_present { self.bump() }
411+
is_present
410412
}
411413

412414
pub fn is_keyword(&self, kw: keywords::Keyword) -> bool {
@@ -458,21 +460,16 @@ impl Parser {
458460
// with a single > and continue. If a GT is not seen,
459461
// signal an error.
460462
pub fn expect_gt(&self) {
461-
if *self.token == token::GT {
462-
self.bump();
463-
} else if *self.token == token::BINOP(token::SHR) {
464-
self.replace_token(
463+
match *self.token {
464+
token::GT => self.bump(),
465+
token::BINOP(token::SHR) => self.replace_token(
465466
token::GT,
466467
self.span.lo + BytePos(1u),
467468
self.span.hi
468-
);
469-
} else {
470-
let mut s: ~str = ~"expected `";
471-
s.push_str(self.token_to_str(&token::GT));
472-
s.push_str("`, found `");
473-
s.push_str(self.this_token_to_str());
474-
s.push_str("`");
475-
self.fatal(s);
469+
),
470+
_ => self.fatal(fmt!("expected `%s`, found `%s`",
471+
self.token_to_str(&token::GT),
472+
self.this_token_to_str()))
476473
}
477474
}
478475

@@ -1114,19 +1111,20 @@ impl Parser {
11141111
}
11151112

11161113
pub fn is_named_argument(&self) -> bool {
1117-
let offset = if *self.token == token::BINOP(token::AND) {
1118-
1
1119-
} else if *self.token == token::BINOP(token::MINUS) {
1120-
1
1121-
} else if *self.token == token::ANDAND {
1122-
1
1123-
} else if *self.token == token::BINOP(token::PLUS) {
1124-
if self.look_ahead(1, |t| *t == token::BINOP(token::PLUS)) {
1125-
2
1126-
} else {
1127-
1
1128-
}
1129-
} else { 0 };
1114+
let offset = match *self.token {
1115+
token::BINOP(token::AND) => 1,
1116+
token::BINOP(token::MINUS) => 1,
1117+
token::ANDAND => 1,
1118+
token::BINOP(token::PLUS) => {
1119+
if self.look_ahead(1, |t| *t == token::BINOP(token::PLUS)) {
1120+
2
1121+
} else {
1122+
1
1123+
}
1124+
},
1125+
_ => 0
1126+
};
1127+
11301128
if offset == 0 {
11311129
is_plain_ident(&*self.token)
11321130
&& self.look_ahead(1, |t| *t == token::COLON)
@@ -1869,21 +1867,26 @@ impl Parser {
18691867
// parse an optional separator followed by a kleene-style
18701868
// repetition token (+ or *).
18711869
pub fn parse_sep_and_zerok(&self) -> (Option<token::Token>, bool) {
1872-
if *self.token == token::BINOP(token::STAR)
1873-
|| *self.token == token::BINOP(token::PLUS) {
1874-
let zerok = *self.token == token::BINOP(token::STAR);
1875-
self.bump();
1876-
(None, zerok)
1877-
} else {
1878-
let sep = self.bump_and_get();
1879-
if *self.token == token::BINOP(token::STAR)
1880-
|| *self.token == token::BINOP(token::PLUS) {
1881-
let zerok = *self.token == token::BINOP(token::STAR);
1882-
self.bump();
1883-
(Some(sep), zerok)
1884-
} else {
1885-
self.fatal("expected `*` or `+`");
1870+
fn parse_zerok(parser: &Parser) -> Option<bool> {
1871+
match *parser.token {
1872+
token::BINOP(token::STAR) | token::BINOP(token::PLUS) => {
1873+
let zerok = *parser.token == token::BINOP(token::STAR);
1874+
parser.bump();
1875+
Some(zerok)
1876+
},
1877+
_ => None
18861878
}
1879+
};
1880+
1881+
match parse_zerok(self) {
1882+
Some(zerok) => return (None, zerok),
1883+
None => {}
1884+
}
1885+
1886+
let separator = self.bump_and_get();
1887+
match parse_zerok(self) {
1888+
Some(zerok) => (Some(separator), zerok),
1889+
None => self.fatal("expected `*` or `+`")
18871890
}
18881891
}
18891892

@@ -2145,39 +2148,45 @@ impl Parser {
21452148
// parse an expression of binops of at least min_prec precedence
21462149
pub fn parse_more_binops(&self, lhs: @expr, min_prec: uint) -> @expr {
21472150
if self.expr_is_complete(lhs) { return lhs; }
2148-
if token::BINOP(token::OR) == *self.token &&
2149-
(*self.restriction == RESTRICT_NO_BAR_OP ||
2150-
*self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) {
2151-
lhs
2152-
} else if token::OROR == *self.token &&
2153-
*self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP {
2154-
lhs
2155-
} else {
2156-
let cur_opt = token_to_binop(self.token);
2157-
match cur_opt {
2158-
Some(cur_op) => {
2159-
let cur_prec = operator_prec(cur_op);
2160-
if cur_prec > min_prec {
2161-
self.bump();
2162-
let expr = self.parse_prefix_expr();
2163-
let rhs = self.parse_more_binops(expr, cur_prec);
2164-
let bin = self.mk_expr(lhs.span.lo, rhs.span.hi,
2165-
self.mk_binary(cur_op, lhs, rhs));
2166-
self.parse_more_binops(bin, min_prec)
2167-
} else {
2168-
lhs
2169-
}
2151+
2152+
// Prevent dynamic borrow errors later on by limiting the
2153+
// scope of the borrows.
2154+
{
2155+
let token: &token::Token = self.token;
2156+
let restriction: &restriction = self.restriction;
2157+
match (token, restriction) {
2158+
(&token::BINOP(token::OR), &RESTRICT_NO_BAR_OP) => return lhs,
2159+
(&token::BINOP(token::OR),
2160+
&RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
2161+
(&token::OROR, &RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) => return lhs,
2162+
_ => { }
2163+
}
2164+
}
2165+
2166+
let cur_opt = token_to_binop(self.token);
2167+
match cur_opt {
2168+
Some(cur_op) => {
2169+
let cur_prec = operator_prec(cur_op);
2170+
if cur_prec > min_prec {
2171+
self.bump();
2172+
let expr = self.parse_prefix_expr();
2173+
let rhs = self.parse_more_binops(expr, cur_prec);
2174+
let bin = self.mk_expr(lhs.span.lo, rhs.span.hi,
2175+
self.mk_binary(cur_op, lhs, rhs));
2176+
self.parse_more_binops(bin, min_prec)
2177+
} else {
2178+
lhs
21702179
}
2171-
None => {
2172-
if as_prec > min_prec && self.eat_keyword(keywords::As) {
2173-
let rhs = self.parse_ty(true);
2174-
let _as = self.mk_expr(lhs.span.lo,
2175-
rhs.span.hi,
2176-
expr_cast(lhs, rhs));
2177-
self.parse_more_binops(_as, min_prec)
2178-
} else {
2179-
lhs
2180-
}
2180+
}
2181+
None => {
2182+
if as_prec > min_prec && self.eat_keyword(keywords::As) {
2183+
let rhs = self.parse_ty(true);
2184+
let _as = self.mk_expr(lhs.span.lo,
2185+
rhs.span.hi,
2186+
expr_cast(lhs, rhs));
2187+
self.parse_more_binops(_as, min_prec)
2188+
} else {
2189+
lhs
21812190
}
21822191
}
21832192
}
@@ -2198,19 +2207,18 @@ impl Parser {
21982207
token::BINOPEQ(op) => {
21992208
self.bump();
22002209
let rhs = self.parse_expr();
2201-
let aop;
2202-
match op {
2203-
token::PLUS => aop = add,
2204-
token::MINUS => aop = subtract,
2205-
token::STAR => aop = mul,
2206-
token::SLASH => aop = div,
2207-
token::PERCENT => aop = rem,
2208-
token::CARET => aop = bitxor,
2209-
token::AND => aop = bitand,
2210-
token::OR => aop = bitor,
2211-
token::SHL => aop = shl,
2212-
token::SHR => aop = shr
2213-
}
2210+
let aop = match op {
2211+
token::PLUS => add,
2212+
token::MINUS => subtract,
2213+
token::STAR => mul,
2214+
token::SLASH => div,
2215+
token::PERCENT => rem,
2216+
token::CARET => bitxor,
2217+
token::AND => bitand,
2218+
token::OR => bitor,
2219+
token::SHL => shl,
2220+
token::SHR => shr
2221+
};
22142222
self.mk_expr(lo, rhs.span.hi,
22152223
self.mk_assign_op(aop, lhs, rhs))
22162224
}
@@ -2759,6 +2767,7 @@ impl Parser {
27592767
self.bump();
27602768
let (before, slice, after) =
27612769
self.parse_pat_vec_elements();
2770+
27622771
self.expect(&token::RBRACKET);
27632772
pat = ast::pat_vec(before, slice, after);
27642773
hi = self.last_span.hi;
@@ -3347,19 +3356,15 @@ impl Parser {
33473356
}
33483357

33493358
// parse a generic use site
3350-
fn parse_generic_values(
3351-
&self) -> (OptVec<ast::Lifetime>, ~[Ty])
3352-
{
3359+
fn parse_generic_values(&self) -> (OptVec<ast::Lifetime>, ~[Ty]) {
33533360
if !self.eat(&token::LT) {
33543361
(opt_vec::Empty, ~[])
33553362
} else {
33563363
self.parse_generic_values_after_lt()
33573364
}
33583365
}
33593366

3360-
fn parse_generic_values_after_lt(
3361-
&self) -> (OptVec<ast::Lifetime>, ~[Ty])
3362-
{
3367+
fn parse_generic_values_after_lt(&self) -> (OptVec<ast::Lifetime>, ~[Ty]) {
33633368
let lifetimes = self.parse_lifetimes();
33643369
let result = self.parse_seq_to_gt(
33653370
Some(token::COMMA),
@@ -3388,11 +3393,7 @@ impl Parser {
33883393
}
33893394

33903395
fn is_self_ident(&self) -> bool {
3391-
match *self.token {
3392-
token::IDENT(id, false) if id == special_idents::self_
3393-
=> true,
3394-
_ => false
3395-
}
3396+
*self.token == token::IDENT(special_idents::self_, false)
33963397
}
33973398

33983399
fn expect_self_ident(&self) {
@@ -4660,14 +4661,12 @@ impl Parser {
46604661

46614662
pub fn parse_item(&self, attrs: ~[Attribute]) -> Option<@ast::item> {
46624663
match self.parse_item_or_view_item(attrs, true) {
4663-
iovi_none(_) =>
4664-
None,
4664+
iovi_none(_) => None,
46654665
iovi_view_item(_) =>
46664666
self.fatal("view items are not allowed here"),
46674667
iovi_foreign_item(_) =>
46684668
self.fatal("foreign items are not allowed here"),
4669-
iovi_item(item) =>
4670-
Some(item)
4669+
iovi_item(item) => Some(item)
46714670
}
46724671
}
46734672

@@ -4830,6 +4829,7 @@ impl Parser {
48304829
// First, parse view items.
48314830
let mut view_items : ~[ast::view_item] = ~[];
48324831
let mut items = ~[];
4832+
48334833
// I think this code would probably read better as a single
48344834
// loop with a mutable three-state-variable (for extern mods,
48354835
// view items, and regular items) ... except that because

0 commit comments

Comments
 (0)