user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Parse type inferred lambda-block expressions.

Browse source
This commit is contained in:
Michael Sullivan 2011-08-12 12:58:37 -07:00
parent 814bf41d89
commit 9b50011aae
1 changed files with 41 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/comp/syntax/parse/parser.rs
View file

@ -600,16 +600,28 @@ fn parse_ty(p: &parser, colons_before_params: bool) -> @ast::ty {
ret parse_ty_postfix(t, p, colons_before_params);
}
fn parse_arg(p: &parser) -> ast::arg {
let m: ast::mode = ast::val;
let i: ast::ident = parse_value_ident(p);
expect(p, token::COLON);
fn parse_arg_mode(p: &parser) -> ast::mode {
if eat(p, token::BINOP(token::AND)) {
m = ast::alias(eat_word(p, "mutable"));
ast::alias(eat_word(p, "mutable"))
} else if eat(p, token::BINOP(token::MINUS)) {
m = ast::move;
ast::move
} else {
ast::val
}
let t: @ast::ty = parse_ty(p, false);
}
fn parse_arg(p: &parser) -> ast::arg {
let i = parse_value_ident(p);
expect(p, token::COLON);
let m = parse_arg_mode(p);
let t = parse_ty(p, false);
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
fn parse_fn_block_arg(p: &parser) -> ast::arg {
let m = parse_arg_mode(p);
let i = parse_value_ident(p);
let t = @spanned(p.get_lo_pos(), p.get_hi_pos(), ast::ty_infer);
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
@ -808,6 +820,8 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
hi = p.get_hi_pos();
expect(p, token::RBRACE);
ex = ast::expr_rec(fields, base);
} else if p.peek() == token::BINOP(token::OR) {
ret parse_fn_block_expr(p);
} else {
let blk = parse_block_tail(p, lo);
ret mk_expr(p, blk.span.lo, blk.span.hi, ast::expr_block(blk));
@ -1314,6 +1328,14 @@ fn parse_fn_expr(p: &parser, proto: ast::proto) -> @ast::expr {
ret mk_expr(p, lo, body.span.hi, ast::expr_fn(_fn));
}
fn parse_fn_block_expr(p: &parser) -> @ast::expr {
let lo = p.get_last_lo_pos();
let decl = parse_fn_block_decl(p);
let body = parse_block_tail(p, lo);
let _fn = {decl: decl, proto: ast::proto_block, body: body};
ret mk_expr(p, lo, body.span.hi, ast::expr_fn(_fn));
}
fn parse_else_expr(p: &parser) -> @ast::expr {
if eat_word(p, "if") {
ret parse_if_expr(p);
@ -1794,6 +1816,18 @@ fn parse_fn_decl(p: &parser, purity: ast::purity, il: ast::inlineness)
}
}
fn parse_fn_block_decl(p: &parser) -> ast::fn_decl {
let inputs: ast::spanned[[ast::arg]] =
parse_seq(token::BINOP(token::OR), token::BINOP(token::OR),
some(token::COMMA), parse_fn_block_arg, p);
ret {inputs: inputs.node,
output: @spanned(p.get_lo_pos(), p.get_hi_pos(), ast::ty_infer),
purity: ast::impure_fn,
il: ast::il_normal,
cf: ast::return,
constraints: ~[]};
}
fn parse_fn(p: &parser, proto: ast::proto, purity: ast::purity,
il: ast::inlineness) -> ast::_fn {
let decl = parse_fn_decl(p, purity, il);