rustc: Parse simple patterns

src/comp/front/ast.rs

@@ -39,6 +39,15 @@
 type block_ = rec(vec[@stmt] stmts,
                   hashmap[ident,uint] index);
 
+type pat = spanned[pat_];
+tag pat_ {
+    pat_wild;
+    pat_bind(ident);
+    pat_tag(ident, vec[@pat]);
+}
+
+type arm = rec(@pat pat, block block);
+
 tag binop {
     add;
     sub;
@@ -104,6 +113,7 @@
     expr_if(@expr, block, option.t[block], ann);
     expr_while(@expr, block, ann);
     expr_do_while(block, @expr, ann);
+    expr_alt(@expr, vec[arm], ann);
     expr_block(block, ann);
     expr_assign(@expr /* TODO: @expr|is_lval */, @expr, ann);
     expr_field(@expr, ident, ann);

src/comp/front/parser.rs

@@ -745,6 +745,38 @@ fn spanned[T](&span lo, &span hi, &T node) -> ast.spanned[T] {
     ret @spanned(lo, hi, ast.expr_do_while(body, cond, ast.ann_none));
 }
 
+impure fn parse_alt_expr(parser p) -> @ast.expr {
+    auto lo = p.get_span();
+    expect(p, token.ALT);
+    expect(p, token.LPAREN);
+    auto discriminant = parse_expr(p);
+    expect(p, token.RPAREN);
+    expect(p, token.LBRACE);
+
+    let vec[ast.arm] arms = vec();
+    while (p.peek() != token.RBRACE) {
+        alt (p.peek()) {
+            case (token.CASE) {
+                p.bump();
+                expect(p, token.LPAREN);
+                auto pat = parse_pat(p);
+                expect(p, token.RPAREN);
+                auto block = parse_block(p);
+                arms += vec(rec(pat=pat, block=block));
+            }
+            case (token.RBRACE) { /* empty */ }
+            case (?tok) {
+                p.err("expected 'case' or '}' when parsing 'alt' statement " +
+                      "but found " + token.to_str(tok));
+            }
+        }
+    }
+
+    auto expr = ast.expr_alt(discriminant, arms, ast.ann_none);
+    auto hi = p.get_span();
+    ret @spanned(lo, hi, expr);
+}
+
 impure fn parse_expr(parser p) -> @ast.expr {
     alt (p.peek()) {
         case (token.LBRACE) {
@@ -761,6 +793,9 @@ fn spanned[T](&span lo, &span hi, &T node) -> ast.spanned[T] {
         case (token.DO) {
             ret parse_do_while_expr(p);
         }
+        case (token.ALT) {
+            ret parse_alt_expr(p);
+        }
         case (_) {
             ret parse_assign_expr(p);
         }
@@ -777,6 +812,48 @@ fn spanned[T](&span lo, &span hi, &T node) -> ast.spanned[T] {
     ret none[@ast.expr];
 }
 
+impure fn parse_pat(parser p) -> @ast.pat {
+    auto lo = p.get_span();
+
+    auto pat = ast.pat_wild;    // FIXME: typestate bug
+    alt (p.peek()) {
+        case (token.UNDERSCORE) { p.bump(); pat = ast.pat_wild; }
+        case (token.QUES) {
+            p.bump();
+            alt (p.peek()) {
+                case (token.IDENT(?id)) { p.bump(); pat = ast.pat_bind(id); }
+                case (?tok) {
+                    p.err("expected identifier after '?' in pattern but " +
+                          "found " + token.to_str(tok));
+                    fail;
+                }
+            }
+        }
+        case (token.IDENT(?id)) {
+            p.bump();
+
+            let vec[@ast.pat] args;
+            alt (p.peek()) {
+                case (token.LPAREN) {
+                    auto f = parse_pat;
+                    args = parse_seq[@ast.pat](token.LPAREN, token.RPAREN,
+                                               some(token.COMMA), f, p).node;
+                }
+                case (_) { args = vec(); }
+            }
+
+            pat = ast.pat_tag(id, args);
+        }
+        case (?tok) {
+            p.err("expected pattern but found " + token.to_str(tok));
+            fail;
+        }
+    }
+
+    auto hi = p.get_span();
+    ret @spanned(lo, hi, pat);
+}
+
 impure fn parse_let(parser p) -> @ast.decl {
     auto lo = p.get_span();