From 1c3e95e0a5d4bfc06d15a52b322567a83c948f72 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Mon, 18 Oct 2010 11:31:31 -0700 Subject: [PATCH] Roll back the expr->lval change. We're now LL(1) again. --- src/comp/front/ast.rs | 13 ++--- src/comp/front/parser.rs | 53 ++------------------ src/comp/middle/fold.rs | 101 +++++++++++++-------------------------- 3 files changed, 39 insertions(+), 128 deletions(-) diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index c89bba969a7..a33373f4305 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -90,15 +90,10 @@ tag expr_ { expr_cast(@expr, @ty); expr_if(@expr, block, option[block]); expr_block(block); - expr_assign(@lval, @expr); - expr_lval(@lval); -} - -type lval = spanned[lval_]; -tag lval_ { - lval_field(@expr, ident); - lval_index(@expr, @expr); - lval_name(name, option[referent]); + expr_assign(@expr /* TODO: @expr : is_lval(@expr) */, @expr); + expr_field(@expr, ident); + expr_index(@expr, @expr); + expr_name(name, option[referent]); } type lit = spanned[lit_]; diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 733e61ea93c..9393a02f07c 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -227,43 +227,6 @@ io fn parse_name(parser p, ast.ident id) -> ast.name { ret spanned(lo, tys.span, rec(ident=id, types=tys.node)); } -/** Parses any field or index selectors. */ -io fn parse_selectors(parser p, @ast.expr ex) -> @ast.expr { - if (p.peek() == token.DOT) { - auto lo = p.get_span(); - p.bump(); - - alt (p.peek()) { - case (token.LPAREN) { - p.bump(); - - auto idx = parse_expr(p); - expect(p, token.RPAREN); - - auto hi = p.get_span(); - auto lval = @spanned(lo, hi, ast.lval_index(ex, idx)); - auto lval_ex = @spanned(lo, hi, ast.expr_lval(lval)); - ret parse_selectors(p, lval_ex); - } - - case (token.IDENT(?ident)) { - p.bump(); - - auto hi = p.get_span(); - auto lval = @spanned(lo, hi, ast.lval_field(ex, ident)); - auto lval_ex = @spanned(lo, hi, ast.expr_lval(lval)); - ret parse_selectors(p, lval_ex); - } - - case (_) { - p.err("expecting '(' or field name after identifier"); - } - } - } - - ret ex; -} - io fn parse_possibly_mutable_expr(parser p) -> tup(bool, @ast.expr) { auto mut; if (p.peek() == token.MUTABLE) { @@ -335,14 +298,6 @@ io fn parse_bottom_expr(parser p) -> @ast.expr { ex = ast.expr_rec(es.node); } - case (token.IDENT(?i)) { - auto n = parse_name(p, i); - hi = p.get_span(); - auto lval = ast.lval_name(n, none[ast.referent]); - auto lval_sp = @spanned(lo, hi, lval); - ex = ast.expr_lval(lval_sp); - } - case (_) { alt (parse_lit(p)) { case (some[ast.lit](?lit)) { @@ -356,7 +311,7 @@ io fn parse_bottom_expr(parser p) -> @ast.expr { } } - ret parse_selectors(p, @spanned(lo, hi, ex)); + ret @spanned(lo, hi, ex); } io fn parse_path_expr(parser p) -> @ast.expr { @@ -372,15 +327,13 @@ io fn parse_path_expr(parser p) -> @ast.expr { case (token.IDENT(?i)) { hi = p.get_span(); p.bump(); - auto lv = @spanned(lo, hi, ast.lval_field(e, i)); - e = @spanned(lo, hi, ast.expr_lval(lv)); + e = @spanned(lo, hi, ast.expr_field(e, i)); } case (token.LPAREN) { auto ix = parse_bottom_expr(p); hi = ix.span; - auto lv = @spanned(lo, hi, ast.lval_index(e, ix)); - e = @spanned(lo, hi, ast.expr_lval(lv)); + e = @spanned(lo, hi, ast.expr_index(e, ix)); } } } diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index ed8cf99847f..f8c058ff35d 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -14,7 +14,6 @@ import front.ast.name; import front.ast.path; import front.ast.ty; import front.ast.expr; -import front.ast.lval; import front.ast.stmt; import front.ast.block; import front.ast.item; @@ -78,21 +77,17 @@ type ast_fold[ENV] = block blk) -> @expr) fold_expr_block, (fn(&ENV e, &span sp, - @lval lhs, @expr rhs) -> @expr) fold_expr_assign, + @expr lhs, @expr rhs) -> @expr) fold_expr_assign, (fn(&ENV e, &span sp, - @lval lv) -> @expr) fold_expr_lval, - - // Lvalue folds. - (fn(&ENV e, &span sp, - @expr e, ident i) -> @lval) fold_lval_field, + @expr e, ident i) -> @expr) fold_expr_field, (fn(&ENV e, &span sp, - @expr e, @expr ix) -> @lval) fold_lval_index, + @expr e, @expr ix) -> @expr) fold_expr_index, (fn(&ENV e, &span sp, &name n, - &option[referent] r) -> @lval) fold_lval_name, + &option[referent] r) -> @expr) fold_expr_name, // Decl folds. (fn(&ENV e, &span sp, @@ -143,7 +138,6 @@ type ast_fold[ENV] = (fn(&ENV e, @item i) -> ENV) update_env_for_item, (fn(&ENV e, @stmt s) -> ENV) update_env_for_stmt, (fn(&ENV e, @decl i) -> ENV) update_env_for_decl, - (fn(&ENV e, @lval l) -> ENV) update_env_for_lval, (fn(&ENV e, @expr x) -> ENV) update_env_for_expr, (fn(&ENV e, @ty t) -> ENV) update_env_for_ty, @@ -244,34 +238,6 @@ fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl { fail; } -fn fold_lval[ENV](&ENV env, ast_fold[ENV] fld, @lval lv) -> @lval { - let ENV env_ = fld.update_env_for_lval(env, lv); - - if (!fld.keep_going(env_)) { - ret lv; - } - - alt (lv.node) { - case (ast.lval_field(?e, ?i)) { - auto ee = fold_expr(env_, fld, e); - ret fld.fold_lval_field(env_, lv.span, ee, i); - } - - case (ast.lval_index(?e, ?ix)) { - auto ee = fold_expr(env_, fld, e); - auto iix = fold_expr(env_, fld, ix); - ret fld.fold_lval_index(env_, lv.span, ee, iix); - } - - case (ast.lval_name(?n, ?r)) { - auto n_ = fold_name(env_, fld, n); - ret fld.fold_lval_name(env_, lv.span, n, r); - } - } - - fail; // shoudn't be reached -} - // FIXME: Weird bug. Due to the way we auto-deref + in +=, we can't append a // boxed value to a vector-of-boxes using +=. Best to figure out a way to fix // this. Deref-on-demand or something? It's a hazard of the ambiguity between @@ -367,14 +333,25 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { } case (ast.expr_assign(?lhs, ?rhs)) { - auto llhs = fold_lval(env_, fld, lhs); + auto llhs = fold_expr(env_, fld, lhs); auto rrhs = fold_expr(env_, fld, rhs); ret fld.fold_expr_assign(env_, e.span, llhs, rrhs); } - case (ast.expr_lval(?lv)) { - auto llv = fold_lval(env_, fld, lv); - ret fld.fold_expr_lval(env_, e.span, llv); + case (ast.expr_field(?e, ?i)) { + auto ee = fold_expr(env_, fld, e); + ret fld.fold_expr_field(env_, e.span, ee, i); + } + + case (ast.expr_index(?e, ?ix)) { + auto ee = fold_expr(env_, fld, e); + auto iix = fold_expr(env_, fld, ix); + ret fld.fold_expr_index(env_, e.span, ee, iix); + } + + case (ast.expr_name(?n, ?r)) { + auto n_ = fold_name(env_, fld, n); + ret fld.fold_expr_name(env_, e.span, n, r); } } @@ -604,30 +581,23 @@ fn identity_fold_expr_block[ENV](&ENV env, &span sp, block blk) -> @expr { } fn identity_fold_expr_assign[ENV](&ENV env, &span sp, - @lval lhs, @expr rhs) -> @expr { + @expr lhs, @expr rhs) -> @expr { ret @respan(sp, ast.expr_assign(lhs, rhs)); } -fn identity_fold_expr_lval[ENV](&ENV env, &span sp, @lval lv) -> @expr { - ret @respan(sp, ast.expr_lval(lv)); +fn identity_fold_expr_field[ENV](&ENV env, &span sp, + @expr e, ident i) -> @expr { + ret @respan(sp, ast.expr_field(e, i)); } - -// Lvalue identities. - -fn identity_fold_lval_field[ENV](&ENV env, &span sp, - @expr e, ident i) -> @lval { - ret @respan(sp, ast.lval_field(e, i)); +fn identity_fold_expr_index[ENV](&ENV env, &span sp, + @expr e, @expr ix) -> @expr { + ret @respan(sp, ast.expr_index(e, ix)); } -fn identity_fold_lval_index[ENV](&ENV env, &span sp, - @expr e, @expr ix) -> @lval { - ret @respan(sp, ast.lval_index(e, ix)); -} - -fn identity_fold_lval_name[ENV](&ENV env, &span sp, - &name n, &option[referent] r) -> @lval { - ret @respan(sp, ast.lval_name(n, r)); +fn identity_fold_expr_name[ENV](&ENV env, &span sp, + &name n, &option[referent] r) -> @expr { + ret @respan(sp, ast.expr_name(n, r)); } @@ -722,10 +692,6 @@ fn identity_update_env_for_decl[ENV](&ENV e, @decl d) -> ENV { ret e; } -fn identity_update_env_for_lval[ENV](&ENV e, @lval l) -> ENV { - ret e; -} - fn identity_update_env_for_expr[ENV](&ENV e, @expr x) -> ENV { ret e; } @@ -769,11 +735,9 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] { fold_expr_if = bind identity_fold_expr_if[ENV](_,_,_,_,_), fold_expr_block = bind identity_fold_expr_block[ENV](_,_,_), fold_expr_assign = bind identity_fold_expr_assign[ENV](_,_,_,_), - fold_expr_lval = bind identity_fold_expr_lval[ENV](_,_,_), - - fold_lval_field = bind identity_fold_lval_field[ENV](_,_,_,_), - fold_lval_index = bind identity_fold_lval_index[ENV](_,_,_,_), - fold_lval_name = bind identity_fold_lval_name[ENV](_,_,_,_), + fold_expr_field = bind identity_fold_expr_field[ENV](_,_,_,_), + fold_expr_index = bind identity_fold_expr_index[ENV](_,_,_,_), + fold_expr_name = bind identity_fold_expr_name[ENV](_,_,_,_), fold_decl_local = bind identity_fold_decl_local[ENV](_,_,_,_,_), fold_decl_item = bind identity_fold_decl_item[ENV](_,_,_,_), @@ -796,7 +760,6 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] { update_env_for_item = bind identity_update_env_for_item[ENV](_,_), update_env_for_stmt = bind identity_update_env_for_stmt[ENV](_,_), update_env_for_decl = bind identity_update_env_for_decl[ENV](_,_), - update_env_for_lval = bind identity_update_env_for_lval[ENV](_,_), update_env_for_expr = bind identity_update_env_for_expr[ENV](_,_), update_env_for_ty = bind identity_update_env_for_ty[ENV](_,_),