Skip to content

Commit 55c9842

Browse files
pcwaltonpcwalton
committed
rustc: Unbreak "3 as uint < 5u"
1 parent 91d83f5 commit 55c9842

File tree

1 file changed

+59
-49
lines changed

1 file changed

+59
-49
lines changed

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

Lines changed: 59 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -272,7 +272,7 @@ fn parse_ty_fn(proto: ast::proto, p: &parser, lo: uint) -> ast::ty_ {
272272
p.bump();
273273
mode = ast::alias(eat_word(p, "mutable"));
274274
}
275-
let t = parse_ty(p);
275+
let t = parse_ty(p, false);
276276
ret spanned(lo, t.span.hi, {mode: mode, ty: t});
277277
}
278278
let lo = p.get_lo_pos();
@@ -337,7 +337,7 @@ fn parse_ty_obj(p: &parser, hi: &mutable uint) -> ast::ty_ {
337337

338338
fn parse_mt(p: &parser) -> ast::mt {
339339
let mut = parse_mutability(p);
340-
let t = parse_ty(p);
340+
let t = parse_ty(p, false);
341341
ret {ty: t, mut: mut};
342342
}
343343

@@ -346,7 +346,7 @@ fn parse_ty_field(p: &parser) -> ast::ty_field {
346346
let mut = parse_mutability(p);
347347
let id = parse_ident(p);
348348
expect(p, token::COLON);
349-
let ty = parse_ty(p);
349+
let ty = parse_ty(p, false);
350350
ret spanned(lo, ty.span.hi, {ident: id, mt: {ty: ty, mut: mut}});
351351
}
352352

@@ -421,46 +421,52 @@ fn parse_type_constraints(p: &parser) -> [@ast::ty_constr] {
421421
ret parse_constrs(parse_constr_in_type, p);
422422
}
423423

424-
fn parse_ty_postfix(orig_t: ast::ty_, p: &parser) -> @ast::ty {
424+
fn parse_ty_postfix(orig_t: ast::ty_, p: &parser, colons_before_params: bool)
425+
-> @ast::ty {
425426
let lo = p.get_lo_pos();
426-
if p.peek() == token::LBRACKET || p.peek() == token::LT {
427-
let end;
428-
if p.peek() == token::LBRACKET {
429-
end = token::RBRACKET;
430-
} else {
431-
end = token::GT;
432-
}
433427

434-
// This is explicit type parameter instantiation.
428+
let end;
429+
if p.peek() == token::LBRACKET {
430+
p.bump();
431+
end = token::RBRACKET;
432+
} else if colons_before_params && p.peek() == token::MOD_SEP {
433+
p.bump();
434+
expect(p, token::LT);
435+
end = token::GT;
436+
} else if !colons_before_params && p.peek() == token::LT {
435437
p.bump();
438+
end = token::GT;
439+
} else {
440+
ret @spanned(lo, p.get_lo_pos(), orig_t);
441+
}
436442

437-
let seq = parse_seq_to_end(end, some(token::COMMA), parse_ty, p);
443+
// If we're here, we have explicit type parameter instantiation.
444+
let seq = parse_seq_to_end(end, some(token::COMMA),
445+
bind parse_ty(_, false), p);
438446

439-
alt orig_t {
440-
ast::ty_path(pth, ann) {
441-
let hi = p.get_hi_pos();
442-
ret @spanned(lo, hi,
443-
ast::ty_path(spanned(lo, hi,
444-
{global: pth.node.global,
445-
idents: pth.node.idents,
446-
types: seq}), ann));
447-
}
448-
_ {
449-
p.fatal("type parameter instantiation only allowed for paths");
450-
}
451-
}
447+
alt orig_t {
448+
ast::ty_path(pth, ann) {
449+
let hi = p.get_hi_pos();
450+
ret @spanned(lo, hi,
451+
ast::ty_path(spanned(lo, hi,
452+
{global: pth.node.global,
453+
idents: pth.node.idents,
454+
types: seq}), ann));
455+
}
456+
_ {
457+
p.fatal("type parameter instantiation only allowed for paths");
458+
}
452459
}
453-
ret @spanned(lo, p.get_lo_pos(), orig_t);
454460
}
455461

456462
fn parse_ty_or_bang(p: &parser) -> ty_or_bang {
457463
alt p.peek() {
458464
token::NOT. { p.bump(); ret a_bang; }
459-
_ { ret a_ty(parse_ty(p)); }
465+
_ { ret a_ty(parse_ty(p, false)); }
460466
}
461467
}
462468

463-
fn parse_ty(p: &parser) -> @ast::ty {
469+
fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
464470
let lo = p.get_lo_pos();
465471
let hi = lo;
466472
let t: ast::ty_;
@@ -511,10 +517,10 @@ fn parse_ty(p: &parser) -> @ast::ty {
511517
p.bump();
512518
t = ast::ty_nil;
513519
} else {
514-
let ts = ~[parse_ty(p)];
520+
let ts = ~[parse_ty(p, false)];
515521
while p.peek() == token::COMMA {
516522
p.bump();
517-
ts += ~[parse_ty(p)];
523+
ts += ~[parse_ty(p, false)];
518524
}
519525
if ivec::len(ts) == 1u {
520526
t = ts.(0).node;
@@ -572,25 +578,25 @@ fn parse_ty(p: &parser) -> @ast::ty {
572578
t = parse_ty_obj(p, hi);
573579
} else if (eat_word(p, "port")) {
574580
expect(p, token::LBRACKET);
575-
t = ast::ty_port(parse_ty(p));
581+
t = ast::ty_port(parse_ty(p, false));
576582
hi = p.get_hi_pos();
577583
expect(p, token::RBRACKET);
578584
} else if (eat_word(p, "chan")) {
579585
expect(p, token::LBRACKET);
580-
t = ast::ty_chan(parse_ty(p));
586+
t = ast::ty_chan(parse_ty(p, false));
581587
hi = p.get_hi_pos();
582588
expect(p, token::RBRACKET);
583589
} else if (eat_word(p, "mutable")) {
584590
p.warn("ignoring deprecated 'mutable' type constructor");
585-
let typ = parse_ty(p);
591+
let typ = parse_ty(p, false);
586592
t = typ.node;
587593
hi = typ.span.hi;
588594
} else if (p.peek() == token::MOD_SEP || is_ident(p.peek())) {
589595
let path = parse_path(p);
590596
t = ast::ty_path(path, p.get_id());
591597
hi = path.span.hi;
592598
} else { p.fatal("expecting type"); }
593-
ret parse_ty_postfix(t, p);
599+
ret parse_ty_postfix(t, p, colons_before_params);
594600
}
595601

596602
fn parse_arg(p: &parser) -> ast::arg {
@@ -602,7 +608,7 @@ fn parse_arg(p: &parser) -> ast::arg {
602608
} else if eat(p, token::BINOP(token::MINUS)) {
603609
m = ast::move;
604610
}
605-
let t: @ast::ty = parse_ty(p);
611+
let t: @ast::ty = parse_ty(p, false);
606612
ret {mode: m, ty: t, ident: i, id: p.get_id()};
607613
}
608614

@@ -706,7 +712,11 @@ fn parse_path(p: &parser) -> ast::path {
706712
ids += ~[p.get_str(i)];
707713
hi = p.get_hi_pos();
708714
p.bump();
709-
if p.peek() == token::MOD_SEP { p.bump(); } else { break; }
715+
if p.peek() == token::MOD_SEP && p.look_ahead(1u) != token::LT {
716+
p.bump();
717+
} else {
718+
break;
719+
}
710720
}
711721
_ { break; }
712722
}
@@ -720,7 +730,7 @@ fn parse_path_and_ty_param_substs(p: &parser) -> ast::path {
720730
if p.peek() == token::LBRACKET {
721731
let seq =
722732
parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA),
723-
parse_ty, p);
733+
bind parse_ty(_, false), p);
724734
let hi = seq.span.hi;
725735
path =
726736
spanned(lo, hi,
@@ -830,7 +840,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
830840
ex = ast::expr_vec(es, mut, ast::sk_rc);
831841
} else if (p.peek() == token::POUND_LT) {
832842
p.bump();
833-
let ty = parse_ty(p);
843+
let ty = parse_ty(p, false);
834844
expect(p, token::GT);
835845

836846
/* hack: early return to take advantage of specialized function */
@@ -976,7 +986,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
976986
let ty = @spanned(lo, hi, ast::ty_infer);
977987
if token::LBRACKET == p.peek() {
978988
expect(p, token::LBRACKET);
979-
ty = parse_ty(p);
989+
ty = parse_ty(p, false);
980990
expect(p, token::RBRACKET);
981991
}
982992
expect(p, token::LPAREN);
@@ -1201,7 +1211,7 @@ fn parse_more_binops(p: &parser, lhs: @ast::expr, min_prec: int) ->
12011211
}
12021212
}
12031213
if as_prec > min_prec && eat_word(p, "as") {
1204-
let rhs = parse_ty(p);
1214+
let rhs = parse_ty(p, true);
12051215
let _as =
12061216
mk_expr(p, lhs.span.lo, rhs.span.hi, ast::expr_cast(lhs, rhs));
12071217
ret parse_more_binops(p, _as, min_prec);
@@ -1521,7 +1531,7 @@ fn parse_local(p: &parser, allow_init: bool) -> @ast::local {
15211531
let lo = p.get_lo_pos();
15221532
let pat = parse_pat(p);
15231533
let ty = @spanned(lo, lo, ast::ty_infer);
1524-
if eat(p, token::COLON) { ty = parse_ty(p); }
1534+
if eat(p, token::COLON) { ty = parse_ty(p, false); }
15251535
let init = if allow_init { parse_initializer(p) } else { none };
15261536
ret @spanned(lo, p.get_last_hi_pos(),
15271537
{ty: ty,
@@ -1814,15 +1824,15 @@ fn parse_obj_field(p: &parser) -> ast::obj_field {
18141824
let mut = parse_mutability(p);
18151825
let ident = parse_value_ident(p);
18161826
expect(p, token::COLON);
1817-
let ty = parse_ty(p);
1827+
let ty = parse_ty(p, false);
18181828
ret {mut: mut, ty: ty, ident: ident, id: p.get_id()};
18191829
}
18201830

18211831
fn parse_anon_obj_field(p: &parser) -> ast::anon_obj_field {
18221832
let mut = parse_mutability(p);
18231833
let ident = parse_value_ident(p);
18241834
expect(p, token::COLON);
1825-
let ty = parse_ty(p);
1835+
let ty = parse_ty(p, false);
18261836
expect(p, token::EQ);
18271837
let expr = parse_expr(p);
18281838
ret {mut: mut, ty: ty, expr: expr, ident: ident, id: p.get_id()};
@@ -1865,7 +1875,7 @@ fn parse_item_res(p: &parser, attrs: &[ast::attribute]) ->
18651875
expect(p, token::LPAREN);
18661876
let arg_ident = parse_value_ident(p);
18671877
expect(p, token::COLON);
1868-
let t = parse_ty(p);
1878+
let t = parse_ty(p, false);
18691879
expect(p, token::RPAREN);
18701880
let dtor = parse_block(p);
18711881
let decl =
@@ -1909,7 +1919,7 @@ fn parse_item_const(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
19091919
let lo = p.get_last_lo_pos();
19101920
let id = parse_value_ident(p);
19111921
expect(p, token::COLON);
1912-
let ty = parse_ty(p);
1922+
let ty = parse_ty(p, false);
19131923
expect(p, token::EQ);
19141924
let e = parse_expr(p);
19151925
let hi = p.get_hi_pos();
@@ -2031,7 +2041,7 @@ fn parse_item_type(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
20312041
let t = parse_type_decl(p);
20322042
let tps = parse_ty_params(p);
20332043
expect(p, token::EQ);
2034-
let ty = parse_ty(p);
2044+
let ty = parse_ty(p, false);
20352045
let hi = p.get_hi_pos();
20362046
expect(p, token::SEMI);
20372047
ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
@@ -2048,7 +2058,7 @@ fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
20482058
p.fatal("found " + id + " in tag constructor position");
20492059
}
20502060
p.bump();
2051-
let ty = parse_ty(p);
2061+
let ty = parse_ty(p, false);
20522062
expect(p, token::SEMI);
20532063
let variant =
20542064
spanned(ty.span.lo, ty.span.hi,
@@ -2072,7 +2082,7 @@ fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
20722082
token::LPAREN. {
20732083
let arg_tys =
20742084
parse_seq(token::LPAREN, token::RPAREN,
2075-
some(token::COMMA), parse_ty, p);
2085+
some(token::COMMA), bind parse_ty(_, false), p);
20762086
for ty: @ast::ty in arg_tys.node {
20772087
args += ~[{ty: ty, id: p.get_id()}];
20782088
}

0 commit comments

Comments
 (0)