Roll back the expr->lval change. We're now LL(1) again.

3 files changed, 39 insertions, 128 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index c89bba96..a33373f4 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 733e61ea..9393a02f 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 ed8cf998..f8c058ff 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,
+         @expr e, ident i) -> @expr)              fold_expr_field,
 
-     // Lvalue folds.
      (fn(&ENV e, &span sp,
-         @expr e, ident i) -> @lval)              fold_lval_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));
-}
-
-
-// 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_field[ENV](&ENV env, &span sp,
+                                 @expr e, ident i) -> @expr {
+    ret @respan(sp, ast.expr_field(e, i));
 }
 
-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_expr_index[ENV](&ENV env, &span sp,
+                                 @expr e, @expr ix) -> @expr {
+    ret @respan(sp, ast.expr_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](_,_),