Skip to content

Commit 66c1ca8

Browse files
marijnhmarijnh
committed
Update the parser to accept the new syntax
1 parent 300eb30 commit 66c1ca8

File tree

1 file changed

+59
-155
lines changed

1 file changed

+59
-155
lines changed

‎src/comp/syntax/parse/parser.rs

Lines changed: 59 additions & 155 deletions
Original file line numberDiff line numberDiff line change
@@ -155,6 +155,7 @@ fn bad_expr_word_table() -> hashmap[str, ()] {
155155
words.insert("do", ());
156156
words.insert("alt", ());
157157
words.insert("for", ());
158+
words.insert("each", ());
158159
words.insert("break", ());
159160
words.insert("cont", ());
160161
words.insert("put", ());
@@ -221,6 +222,11 @@ fn parse_value_ident(&parser p) -> ast::ident {
221222
ret parse_ident(p);
222223
}
223224

225+
fn eat(&parser p, &token::token tok) -> bool {
226+
ret if p.peek() == tok { p.bump(); true }
227+
else { false };
228+
}
229+
224230
fn is_word(&parser p, &str word) -> bool {
225231
ret alt (p.peek()) {
226232
case (token::IDENT(?sid, false)) { str::eq(word, p.get_str(sid)) }
@@ -262,16 +268,16 @@ fn check_bad_word(&parser p) {
262268
fn parse_ty_fn(ast::proto proto, &parser p, uint lo) -> ast::ty_ {
263269
fn parse_fn_input_ty(&parser p) -> ast::ty_arg {
264270
auto lo = p.get_lo_pos();
271+
// Ignore arg name, if present
272+
if is_plain_ident(p) && p.look_ahead(1u) == token::COLON {
273+
p.bump(); p.bump();
274+
}
265275
auto mode = ast::val;
266276
if (p.peek() == token::BINOP(token::AND)) {
267277
p.bump();
268278
mode = ast::alias(eat_word(p, "mutable"));
269279
}
270280
auto t = parse_ty(p);
271-
alt (p.peek()) {
272-
case (token::IDENT(_, _)) { p.bump();/* ignore param name */ }
273-
case (_) {/* no param name present */ }
274-
}
275281
ret spanned(lo, t.span.hi, rec(mode=mode, ty=t));
276282
}
277283
auto lo = p.get_lo_pos();
@@ -342,14 +348,6 @@ fn parse_mt(&parser p) -> ast::mt {
342348
}
343349

344350
fn parse_ty_field(&parser p) -> ast::ty_field {
345-
auto lo = p.get_lo_pos();
346-
auto mt = parse_mt(p);
347-
auto id = parse_ident(p);
348-
ret spanned(lo, mt.ty.span.hi, rec(ident=id, mt=mt));
349-
}
350-
351-
// FIXME rename to parse_ty_field once the other one is dropped
352-
fn parse_ty_field_modern(&parser p) -> ast::ty_field {
353351
auto lo = p.get_lo_pos();
354352
auto mut = parse_mutability(p);
355353
auto id = parse_ident(p);
@@ -555,7 +553,7 @@ fn parse_ty(&parser p) -> @ast::ty {
555553
t = ast::ty_ptr(mt);
556554
} else if (p.peek() == token::LBRACE) {
557555
auto elems = parse_seq(token::LBRACE, token::RBRACE,
558-
some(token::COMMA), parse_ty_field_modern, p);
556+
some(token::COMMA), parse_ty_field, p);
559557
hi = elems.span.hi;
560558
t = ast::ty_rec(elems.node);
561559
if (p.peek() == token::COLON) {
@@ -568,20 +566,6 @@ fn parse_ty(&parser p) -> @ast::ty {
568566
t = ast::ty_vec(parse_mt(p));
569567
hi = p.get_hi_pos();
570568
expect(p, token::RBRACKET);
571-
} else if (eat_word(p, "rec")) {
572-
auto elems =
573-
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
574-
parse_ty_field, p);
575-
hi = elems.span.hi;
576-
// possible constrs
577-
// FIXME: something seems dodgy or at least repetitive
578-
// about how constrained types get parsed
579-
t = ast::ty_rec(elems.node);
580-
if (p.peek() == token::COLON) {
581-
p.bump();
582-
t = ast::ty_constr(@spanned(lo, hi, t),
583-
parse_type_constraints(p));
584-
}
585569
} else if (eat_word(p, "fn")) {
586570
auto flo = p.get_last_lo_pos();
587571
t = parse_ty_fn(ast::proto_fn, p, flo);
@@ -621,12 +605,12 @@ fn parse_ty(&parser p) -> @ast::ty {
621605

622606
fn parse_arg(&parser p) -> ast::arg {
623607
let ast::mode m = ast::val;
624-
if (p.peek() == token::BINOP(token::AND)) {
625-
p.bump();
608+
let ast::ident i = parse_value_ident(p);
609+
expect(p, token::COLON);
610+
if eat(p, token::BINOP(token::AND)) {
626611
m = ast::alias(eat_word(p, "mutable"));
627612
}
628613
let @ast::ty t = parse_ty(p);
629-
let ast::ident i = parse_value_ident(p);
630614
ret rec(mode=m, ty=t, ident=i, id=p.get_id());
631615
}
632616

@@ -710,6 +694,10 @@ fn is_ident(token::token t) -> bool {
710694
ret false;
711695
}
712696

697+
fn is_plain_ident(&parser p) -> bool {
698+
ret alt p.peek() { token::IDENT(_, false) { true } _ { false } };
699+
}
700+
713701
fn parse_path(&parser p) -> ast::path {
714702
auto lo = p.get_lo_pos();
715703
auto hi = lo;
@@ -806,8 +794,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
806794
} else if (p.peek() == token::LBRACE) {
807795
p.bump();
808796
if (is_word(p, "mutable") ||
809-
alt p.peek() { token::IDENT(_, false) { true } _ { false } } &&
810-
p.look_ahead(1u) == token::COLON) {
797+
is_plain_ident(p) && p.look_ahead(1u) == token::COLON) {
811798
auto fields = ~[parse_field(p, token::COLON)];
812799
auto base = none;
813800
while p.peek() != token::RBRACE {
@@ -915,27 +902,6 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
915902
let ast::anon_obj ob =
916903
rec(fields=fields, methods=meths, with_obj=with_obj);
917904
ex = ast::expr_anon_obj(ob);
918-
} else if (eat_word(p, "rec")) {
919-
expect(p, token::LPAREN);
920-
auto fields = ~[parse_field(p, token::EQ)];
921-
auto more = true;
922-
auto base = none;
923-
while (more) {
924-
if (p.peek() == token::RPAREN) {
925-
hi = p.get_hi_pos();
926-
p.bump();
927-
more = false;
928-
} else if (eat_word(p, "with")) {
929-
base = some(parse_expr(p));
930-
hi = p.get_hi_pos();
931-
expect(p, token::RPAREN);
932-
more = false;
933-
} else if (p.peek() == token::COMMA) {
934-
p.bump();
935-
fields += ~[parse_field(p, token::EQ)];
936-
} else { unexpected(p, p.peek()); }
937-
}
938-
ex = ast::expr_rec(fields, base);
939905
} else if (eat_word(p, "bind")) {
940906
auto e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
941907
fn parse_expr_opt(&parser p) -> option::t[@ast::expr] {
@@ -1349,25 +1315,15 @@ fn parse_else_expr(&parser p) -> @ast::expr {
13491315
}
13501316
}
13511317

1352-
fn parse_head_local(&parser p) -> @ast::local {
1353-
if (eat_word(p, "auto")) {
1354-
ret parse_auto_local(p);
1355-
} else {
1356-
ret parse_typed_local(p);
1357-
}
1358-
}
1359-
13601318
fn parse_for_expr(&parser p) -> @ast::expr {
13611319
auto lo = p.get_last_lo_pos();
13621320
auto is_each = eat_word(p, "each");
1363-
expect(p, token::LPAREN);
1364-
auto decl = parse_head_local(p);
1321+
auto decl = parse_local(p, false);
13651322
expect_word(p, "in");
13661323
auto seq = parse_expr(p);
1367-
expect(p, token::RPAREN);
13681324
auto body = parse_block(p);
13691325
auto hi = body.span.hi;
1370-
if (is_each) {
1326+
if is_each {
13711327
ret mk_expr(p, lo, hi, ast::expr_for_each(decl, seq, body));
13721328
} else {
13731329
ret mk_expr(p, lo, hi, ast::expr_for(decl, seq, body));
@@ -1483,21 +1439,6 @@ fn parse_pat(&parser p) -> @ast::pat {
14831439
p.bump();
14841440
pat = ast::pat_wild;
14851441
}
1486-
case (token::QUES) {
1487-
p.bump();
1488-
alt (p.peek()) {
1489-
case (token::IDENT(?id, _)) {
1490-
hi = p.get_hi_pos();
1491-
p.bump();
1492-
pat = ast::pat_bind(p.get_str(id));
1493-
}
1494-
case (?tok) {
1495-
p.fatal("expected identifier after '?' in pattern but " +
1496-
"found " + token::to_str(p.get_reader(), tok));
1497-
fail;
1498-
}
1499-
}
1500-
}
15011442
case (token::AT) {
15021443
p.bump();
15031444
auto sub = parse_pat(p);
@@ -1548,6 +1489,15 @@ fn parse_pat(&parser p) -> @ast::pat {
15481489
auto lit = parse_lit(p);
15491490
hi = lit.span.hi;
15501491
pat = ast::pat_lit(@lit);
1492+
} else if (is_plain_ident(p) &&
1493+
alt p.look_ahead(1u) {
1494+
token::DOT | token::LPAREN | token::LBRACKET {
1495+
false
1496+
}
1497+
_ { true }
1498+
}) {
1499+
hi = p.get_hi_pos();
1500+
pat = ast::pat_bind(parse_ident(p));
15511501
} else {
15521502
auto tag_path = parse_path_and_ty_param_substs(p);
15531503
hi = tag_path.span.hi;
@@ -1559,7 +1509,11 @@ fn parse_pat(&parser p) -> @ast::pat {
15591509
args = a.node;
15601510
hi = a.span.hi;
15611511
}
1562-
case (_) { args = ~[]; }
1512+
case (token::DOT) {
1513+
args = ~[];
1514+
p.bump();
1515+
}
1516+
case (_) { expect(p, token::LPAREN); fail; }
15631517
}
15641518
pat = ast::pat_tag(tag_path, args);
15651519
}
@@ -1568,81 +1522,30 @@ fn parse_pat(&parser p) -> @ast::pat {
15681522
ret @rec(id=p.get_id(), node=pat, span=rec(lo=lo, hi=hi));
15691523
}
15701524

1571-
fn parse_local_full(&option::t[@ast::ty] tyopt, &parser p)
1572-
-> @ast::local {
1525+
fn parse_local(&parser p, bool allow_init) -> @ast::local {
15731526
auto lo = p.get_lo_pos();
15741527
auto ident = parse_value_ident(p);
1575-
auto init = parse_initializer(p);
1576-
ret @spanned(lo, p.get_hi_pos(),
1577-
rec(ty=tyopt,
1578-
infer=false,
1579-
ident=ident,
1580-
init=init,
1581-
id=p.get_id()));
1582-
}
1583-
1584-
fn parse_typed_local(&parser p) -> @ast::local {
1585-
auto ty = parse_ty(p);
1586-
ret parse_local_full(some(ty), p);
1587-
}
1588-
1589-
fn parse_auto_local(&parser p) -> @ast::local {
1590-
ret parse_local_full(none, p);
1591-
}
1592-
1593-
// FIXME simplify when old syntax is no longer supported
1594-
fn parse_let(&parser p) -> @ast::decl {
1595-
if alt p.peek() { token::IDENT(_, false) { true } _ { false } } {
1596-
alt p.look_ahead(1u) {
1597-
token::COLON | token::SEMI | token::COMMA | token::EQ |
1598-
token::LARROW {
1599-
ret parse_let_modern(p);
1600-
}
1601-
_ {}
1602-
}
1528+
auto ty = none;
1529+
if eat(p, token::COLON) {
1530+
ty = some(parse_ty(p));
16031531
}
1604-
auto lo = p.get_last_lo_pos();
1605-
auto locals = ~[parse_typed_local(p)];
1606-
while p.peek() == token::COMMA {
1607-
p.bump();
1608-
locals += ~[parse_typed_local(p)];
1609-
}
1610-
ret @spanned(lo, p.get_hi_pos(), ast::decl_local(locals));
1532+
auto init = if allow_init { parse_initializer(p) }
1533+
else { none };
1534+
ret @spanned(lo, p.get_last_hi_pos(),
1535+
rec(ty=ty, infer=false, ident=ident,
1536+
init=init, id=p.get_id()));
16111537
}
16121538

1613-
fn parse_let_modern(&parser p) -> @ast::decl {
1614-
fn parse_local(&parser p) -> @ast::local {
1615-
auto lo = p.get_lo_pos();
1616-
auto ident = parse_value_ident(p);
1617-
auto ty = none;
1618-
if p.peek() == token::COLON {
1619-
p.bump();
1620-
ty = some(parse_ty(p));
1621-
}
1622-
auto init = parse_initializer(p);
1623-
ret @spanned(lo, p.get_last_hi_pos(),
1624-
rec(ty=ty, infer=false, ident=ident,
1625-
init=init, id=p.get_id()));
1626-
}
1539+
fn parse_let(&parser p) -> @ast::decl {
16271540
auto lo = p.get_lo_pos();
1628-
auto locals = ~[parse_local(p)];
1541+
auto locals = ~[parse_local(p, true)];
16291542
while p.peek() == token::COMMA {
16301543
p.bump();
1631-
locals += ~[parse_local(p)];
1544+
locals += ~[parse_local(p, true)];
16321545
}
16331546
ret @spanned(lo, p.get_last_hi_pos(), ast::decl_local(locals));
16341547
}
16351548

1636-
fn parse_auto(&parser p) -> @ast::decl {
1637-
auto lo = p.get_last_lo_pos();
1638-
auto locals = ~[parse_auto_local(p)];
1639-
while p.peek() == token::COMMA {
1640-
p.bump();
1641-
locals += ~[parse_auto_local(p)];
1642-
}
1643-
ret @spanned(lo, p.get_hi_pos(), ast::decl_local(locals));
1644-
}
1645-
16461549
fn parse_stmt(&parser p) -> @ast::stmt {
16471550
if (p.get_file_type() == SOURCE_FILE) {
16481551
ret parse_source_stmt(p);
@@ -1660,9 +1563,6 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {
16601563
if (eat_word(p, "let")) {
16611564
auto decl = parse_let(p);
16621565
ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
1663-
} else if (eat_word(p, "auto")) {
1664-
auto decl = parse_auto(p);
1665-
ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
16661566
} else {
16671567

16681568
auto item_attrs;
@@ -1850,11 +1750,11 @@ fn parse_ty_params(&parser p) -> ast::ty_param[] {
18501750
fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
18511751
let ast::spanned[ast::arg[]] inputs =
18521752
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
1853-
parse_arg, p);
1753+
parse_arg, p);
18541754
let ty_or_bang rslt;
1855-
// Use the args list to translate each bound variable
1856-
// mentioned in a constraint to an arg index.
1857-
// Seems weird to do this in the parser, but I'm not sure how else to.
1755+
// Use the args list to translate each bound variable
1756+
// mentioned in a constraint to an arg index.
1757+
// Seems weird to do this in the parser, but I'm not sure how else to.
18581758
auto constrs = ~[];
18591759
if (p.peek() == token::COLON) {
18601760
p.bump();
@@ -1917,15 +1817,17 @@ fn parse_item_fn_or_iter(&parser p, ast::purity purity, ast::proto proto,
19171817

19181818
fn parse_obj_field(&parser p) -> ast::obj_field {
19191819
auto mut = parse_mutability(p);
1920-
auto ty = parse_ty(p);
19211820
auto ident = parse_value_ident(p);
1821+
expect(p, token::COLON);
1822+
auto ty = parse_ty(p);
19221823
ret rec(mut=mut, ty=ty, ident=ident, id=p.get_id());
19231824
}
19241825

19251826
fn parse_anon_obj_field(&parser p) -> ast::anon_obj_field {
19261827
auto mut = parse_mutability(p);
1927-
auto ty = parse_ty(p);
19281828
auto ident = parse_value_ident(p);
1829+
expect(p, token::COLON);
1830+
auto ty = parse_ty(p);
19291831
expect(p, token::EQ);
19301832
auto expr = parse_expr(p);
19311833
ret rec(mut=mut, ty=ty, expr=expr, ident=ident, id=p.get_id());
@@ -1988,8 +1890,9 @@ fn parse_item_res(&parser p, ast::layer lyr, &ast::attribute[] attrs) ->
19881890
auto ident = parse_value_ident(p);
19891891
auto ty_params = parse_ty_params(p);
19901892
expect(p, token::LPAREN);
1991-
auto t = parse_ty(p);
19921893
auto arg_ident = parse_value_ident(p);
1894+
expect(p, token::COLON);
1895+
auto t = parse_ty(p);
19931896
expect(p, token::RPAREN);
19941897
auto dtor = parse_block(p);
19951898
auto decl = rec(inputs=~[rec(mode=ast::alias(false), ty=t,
@@ -2029,8 +1932,9 @@ fn parse_mod_items(&parser p, token::token term,
20291932

20301933
fn parse_item_const(&parser p, &ast::attribute[] attrs) -> @ast::item {
20311934
auto lo = p.get_last_lo_pos();
2032-
auto ty = parse_ty(p);
20331935
auto id = parse_value_ident(p);
1936+
expect(p, token::COLON);
1937+
auto ty = parse_ty(p);
20341938
expect(p, token::EQ);
20351939
auto e = parse_expr(p);
20361940
auto hi = p.get_hi_pos();

0 commit comments

Comments
 (0)