From 0107d6a81d2180d3a1e070e982e346038195cada Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 16 Aug 2011 09:07:26 -0700 Subject: [PATCH] Change type parameter syntax to foo. This preserves the old syntax for now. --- src/comp/syntax/parse/parser.rs | 67 ++++++++++++++++++++++++++++----- src/comp/syntax/print/pprust.rs | 14 +++---- 2 files changed, 64 insertions(+), 17 deletions(-) diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index 780d67b4b27b..b1a4a92373df 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -35,6 +35,7 @@ type parser = obj { fn peek() -> token::token ; fn bump() ; + fn swap(token::token, uint, uint) ; fn look_ahead(uint) -> token::token ; fn fatal(str) -> ! ; fn warn(str) ; @@ -97,6 +98,10 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader, tok_span = next.span; } } + fn swap(next: token::token, lo: uint, hi: uint) { + tok = next; + tok_span = ast::mk_sp(lo, hi); + } fn look_ahead(distance: uint) -> token::token { while vec::len(buffer) < distance { let next = lexer::next_token(rdr); @@ -202,6 +207,23 @@ fn expect(p: &parser, t: token::token) { } } +fn expect_gt(p: &parser) { + if p.peek() == token::GT { + p.bump(); + } else if p.peek() == token::BINOP(token::LSR) { + p.swap(token::GT, p.get_lo_pos() + 1u, p.get_hi_pos()); + } else if p.peek() == token::BINOP(token::ASR) { + p.swap(token::BINOP(token::LSR), p.get_lo_pos() + 1u, + p.get_hi_pos()); + } else { + let s: str = "expecting "; + s += token::to_str(p.get_reader(), token::GT); + s += ", found "; + s += token::to_str(p.get_reader(), p.peek()); + p.fatal(s); + } +} + fn spanned[T](lo: uint, hi: uint, node: &T) -> spanned[T] { ret {node: node, span: ast::mk_sp(lo, hi)}; } @@ -426,24 +448,23 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: &parser, colons_before_params: bool) -> @ast::ty { let lo = p.get_lo_pos(); - let end; + let seq; if p.peek() == token::LBRACKET { p.bump(); - end = token::RBRACKET; + seq = parse_seq_to_end(token::RBRACKET, some(token::COMMA), + bind parse_ty(_, false), p); } else if colons_before_params && p.peek() == token::MOD_SEP { p.bump(); expect(p, token::LT); - end = token::GT; + seq = parse_seq_to_gt(some(token::COMMA), bind parse_ty(_, false), p); } else if !colons_before_params && p.peek() == token::LT { p.bump(); - end = token::GT; + seq = parse_seq_to_gt(some(token::COMMA), bind parse_ty(_, false), p); } else { ret @spanned(lo, p.get_lo_pos(), orig_t); } // If we're here, we have explicit type parameter instantiation. - let seq = parse_seq_to_end(end, some(token::COMMA), - bind parse_ty(_, false), p); alt orig_t { ast::ty_path(pth, ann) { @@ -554,10 +575,17 @@ fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty { parse_type_constraints(p)); } } else if (eat_word(p, "vec")) { - expect(p, token::LBRACKET); - t = ast::ty_vec(parse_mt(p)); - hi = p.get_hi_pos(); - expect(p, token::RBRACKET); + if p.peek() == token::LBRACKET { + p.bump(); + t = ast::ty_vec(parse_mt(p)); + hi = p.get_hi_pos(); + expect(p, token::RBRACKET); + } else { + expect(p, token::LT); + t = ast::ty_vec(parse_mt(p)); + hi = p.get_hi_pos(); + expect_gt(p); + } } else if (p.peek() == token::LBRACKET) { expect(p, token::LBRACKET); t = ast::ty_ivec(parse_mt(p)); @@ -615,6 +643,25 @@ fn parse_fn_block_arg(p: &parser) -> ast::arg { ret {mode: m, ty: t, ident: i, id: p.get_id()}; } +fn parse_seq_to_gt[T](sep: option::t[token::token], f: fn(&parser) -> T, + p: &parser) -> [T] { + let first = true; + let v = ~[]; + while p.peek() != token::GT && + p.peek() != token::BINOP(token::LSR) && + p.peek() != token::BINOP(token::ASR) { + alt sep { + some(t) { if first { first = false; } else { expect(p, t); } } + _ { } + } + v += ~[f(p)]; + } + + expect_gt(p); + + ret v; +} + fn parse_seq_to_end[T](ket: token::token, sep: option::t[token::token], f: fn(&parser) -> T , p: &parser) -> [T] { let val = parse_seq_to_before_end(ket, sep, f, p); diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index c3291314c70b..d2af60096ec2 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -282,7 +282,7 @@ fn print_type(s: &ps, ty: &@ast::ty) { ast::ty_str. { word(s.s, "str"); } ast::ty_istr. { word(s.s, "istr"); } ast::ty_box(mt) { word(s.s, "@"); print_mt(s, mt); } - ast::ty_vec(mt) { word(s.s, "vec["); print_mt(s, mt); word(s.s, "]"); } + ast::ty_vec(mt) { word(s.s, "vec<"); print_mt(s, mt); word(s.s, ">"); } ast::ty_ivec(mt) { word(s.s, "["); alt mt.mut { @@ -296,14 +296,14 @@ fn print_type(s: &ps, ty: &@ast::ty) { ast::ty_ptr(mt) { word(s.s, "*"); print_mt(s, mt); } ast::ty_task. { word(s.s, "task"); } ast::ty_port(t) { - word(s.s, "port["); + word(s.s, "port<"); print_type(s, t); - word(s.s, "]"); + word(s.s, ">"); } ast::ty_chan(t) { - word(s.s, "chan["); + word(s.s, "chan<"); print_type(s, t); - word(s.s, "]"); + word(s.s, ">"); } ast::ty_rec(fields) { word(s.s, "{"); @@ -1097,9 +1097,9 @@ fn print_path(s: &ps, path: &ast::path) { word(s.s, id); } if vec::len(path.node.types) > 0u { - word(s.s, "["); + word(s.s, "<"); commasep(s, inconsistent, path.node.types, print_type); - word(s.s, "]"); + word(s.s, ">"); } }