Merge remote branch 'brson/recursive-elseif'

3 files changed, 35 insertions, 50 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 8507298d..a7ff64fa 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -223,7 +223,7 @@ tag expr_ {
     expr_unary(unop, @expr, ann);
     expr_lit(@lit, ann);
     expr_cast(@expr, @ty, ann);
-    expr_if(@expr, block, vec[tup(@expr, block)], option.t[block], ann);
+    expr_if(@expr, block, option.t[@expr], ann);
     expr_while(@expr, block, ann);
     expr_for(@decl, @expr, block, ann);
     expr_for_each(@decl, @expr, block, ann);
diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index 77f3acd1..ac249848 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -289,7 +289,7 @@ impure fn eval_crate_directive_expr(parser p,
 
     alt (x.node) {
 
-        case (ast.expr_if(?cond, ?thn, ?elifs, ?elopt, _)) {
+        case (ast.expr_if(?cond, ?thn, ?elopt, _)) {
             auto cv = eval_expr(sess, e, cond);
             if (!val_is_bool(cv)) {
                 sess.span_err(x.span, "bad cond type in 'if'");
@@ -301,24 +301,11 @@ impure fn eval_crate_directive_expr(parser p,
                                                index);
             }
 
-            for (tup(@ast.expr, ast.block) elif in elifs) {
-                auto cv = eval_expr(sess, e, elif._0);
-                if (!val_is_bool(cv)) {
-                    sess.span_err(x.span, "bad cond type in 'else if'");
-                }
-
-                if (val_as_bool(cv)) {
-                    ret eval_crate_directive_block(p, e, elif._1, prefix,
-                                                   view_items, items,
-                                                   index);
-                }
-            }
-
             alt (elopt) {
-                case (some[ast.block](?els)) {
-                    ret eval_crate_directive_block(p, e, els, prefix,
-                                                   view_items, items,
-                                                   index);
+                case (some[@ast.expr](?els)) {
+                    ret eval_crate_directive_expr(p, e, els, prefix,
+                                                  view_items, items,
+                                                  index);
                 }
                 case (_) {
                     // Absent-else is ok.
@@ -353,6 +340,12 @@ impure fn eval_crate_directive_expr(parser p,
             sess.span_err(x.span, "no cases matched in 'alt'");
         }
 
+        case (ast.expr_block(?block, _)) {
+            ret eval_crate_directive_block(p, e, block, prefix,
+                                           view_items, items,
+                                           index);
+        }
+
         case (_) {
             sess.span_err(x.span, "unsupported expr type");
         }
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index b2aa6495..df57bc19 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -1139,40 +1139,32 @@ impure fn parse_if_expr(parser p) -> @ast.expr {
     auto cond = parse_expr(p);
     expect(p, token.RPAREN);
     auto thn = parse_block(p);
+    let option.t[@ast.expr] els = none[@ast.expr];
     hi = thn.span;
-
-    let vec[tup(@ast.expr, ast.block)] elifs = vec();
-    let option.t[ast.block] els = none[ast.block];
-    let bool parsing_elses = true;
-    while (parsing_elses) {
-        alt (p.peek()) {
-            case (token.ELSE) {
-                expect(p, token.ELSE);
-                alt (p.peek()) {
-                    case (token.IF) {
-                        expect(p, token.IF);
-                        expect(p, token.LPAREN);
-                        auto elifcond = parse_expr(p);
-                        expect(p, token.RPAREN);
-                        auto elifthn = parse_block(p);
-                        elifs += tup(elifcond, elifthn);
-                        hi = elifthn.span;
-                    }
-                    case (_) {
-                        auto eblk = parse_block(p);
-                        els = some(eblk);
-                        hi = eblk.span;
-                        parsing_elses = false;
-                    }
-                }
-            }
-            case (_) {
-                parsing_elses = false;
-            }
+    alt (p.peek()) {
+        case (token.ELSE) {
+            auto elexpr = parse_else_expr(p);
+            els = some(elexpr);
+            hi = elexpr.span;
         }
+        case (_) { /* fall through */ }
     }
 
-    ret @spanned(lo, hi, ast.expr_if(cond, thn, elifs, els, ast.ann_none));
+    ret @spanned(lo, hi, ast.expr_if(cond, thn, els, ast.ann_none));
+}
+
+impure fn parse_else_expr(parser p) -> @ast.expr {
+    expect(p, token.ELSE);
+    alt (p.peek()) {
+        case (token.IF) {
+            ret parse_if_expr(p);
+        }
+        case (_) {
+            auto blk = parse_block(p);
+            ret @spanned(blk.span, blk.span,
+                         ast.expr_block(blk, ast.ann_none));
+        }
+    }
 }
 
 impure fn parse_head_local(parser p) -> @ast.decl {
@@ -1575,7 +1567,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
                 case (ast.expr_unary(_,_,_))    { ret true; }
                 case (ast.expr_lit(_,_))        { ret true; }
                 case (ast.expr_cast(_,_,_))     { ret true; }
-                case (ast.expr_if(_,_,_,_,_))   { ret false; }
+                case (ast.expr_if(_,_,_,_))     { ret false; }
                 case (ast.expr_for(_,_,_,_))    { ret false; }
                 case (ast.expr_for_each(_,_,_,_))
                     { ret false; }