Skip to content

Commit 9a99f5b

Browse files
mstewartgallusmstewartgallus
committed
Cleanup libsyntax a bit
1 parent fc05819 commit 9a99f5b

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)
@@ -1868,21 +1866,26 @@ impl Parser {
18681866
// parse an optional separator followed by a kleene-style
18691867
// repetition token (+ or *).
18701868
pub fn parse_sep_and_zerok(&self) -> (Option<token::Token>, bool) {
1871-
if *self.token == token::BINOP(token::STAR)
1872-
|| *self.token == token::BINOP(token::PLUS) {
1873-
let zerok = *self.token == token::BINOP(token::STAR);
1874-
self.bump();
1875-
(None, zerok)
1876-
} else {
1877-
let sep = self.bump_and_get();
1878-
if *self.token == token::BINOP(token::STAR)
1879-
|| *self.token == token::BINOP(token::PLUS) {
1880-
let zerok = *self.token == token::BINOP(token::STAR);
1881-
self.bump();
1882-
(Some(sep), zerok)
1883-
} else {
1884-
self.fatal("expected `*` or `+`");
1869+
fn parse_zerok(parser: &Parser) -> Option<bool> {
1870+
match *parser.token {
1871+
token::BINOP(token::STAR) | token::BINOP(token::PLUS) => {
1872+
let zerok = *parser.token == token::BINOP(token::STAR);
1873+
parser.bump();
1874+
Some(zerok)
1875+
},
1876+
_ => None
18851877
}
1878+
};
1879+
1880+
match parse_zerok(self) {
1881+
Some(zerok) => return (None, zerok),
1882+
None => {}
1883+
}
1884+
1885+
let separator = self.bump_and_get();
1886+
match parse_zerok(self) {
1887+
Some(zerok) => (Some(separator), zerok),
1888+
None => self.fatal("expected `*` or `+`")
18861889
}
18871890
}
18881891

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

33513360
// parse a generic use site
3352-
fn parse_generic_values(
3353-
&self) -> (OptVec<ast::Lifetime>, ~[Ty])
3354-
{
3361+
fn parse_generic_values(&self) -> (OptVec<ast::Lifetime>, ~[Ty]) {
33553362
if !self.eat(&token::LT) {
33563363
(opt_vec::Empty, ~[])
33573364
} else {
33583365
self.parse_generic_values_after_lt()
33593366
}
33603367
}
33613368

3362-
fn parse_generic_values_after_lt(
3363-
&self) -> (OptVec<ast::Lifetime>, ~[Ty])
3364-
{
3369+
fn parse_generic_values_after_lt(&self) -> (OptVec<ast::Lifetime>, ~[Ty]) {
33653370
let lifetimes = self.parse_lifetimes();
33663371
let result = self.parse_seq_to_gt(
33673372
Some(token::COMMA),
@@ -3390,11 +3395,7 @@ impl Parser {
33903395
}
33913396

33923397
fn is_self_ident(&self) -> bool {
3393-
match *self.token {
3394-
token::IDENT(id, false) if id == special_idents::self_
3395-
=> true,
3396-
_ => false
3397-
}
3398+
*self.token == token::IDENT(special_idents::self_, false)
33983399
}
33993400

34003401
fn expect_self_ident(&self) {
@@ -4649,14 +4650,12 @@ impl Parser {
46494650

46504651
pub fn parse_item(&self, attrs: ~[Attribute]) -> Option<@ast::item> {
46514652
match self.parse_item_or_view_item(attrs, true) {
4652-
iovi_none(_) =>
4653-
None,
4653+
iovi_none(_) => None,
46544654
iovi_view_item(_) =>
46554655
self.fatal("view items are not allowed here"),
46564656
iovi_foreign_item(_) =>
46574657
self.fatal("foreign items are not allowed here"),
4658-
iovi_item(item) =>
4659-
Some(item)
4658+
iovi_item(item) => Some(item)
46604659
}
46614660
}
46624661

@@ -4819,6 +4818,7 @@ impl Parser {
48194818
// First, parse view items.
48204819
let mut view_items : ~[ast::view_item] = ~[];
48214820
let mut items = ~[];
4821+
48224822
// I think this code would probably read better as a single
48234823
// loop with a mutable three-state-variable (for extern mods,
48244824
// view items, and regular items) ... except that because

0 commit comments

Comments
 (0)