---

yaml
---
r: 42879
b: refs/heads/try
c: 4af7c64
h: refs/heads/master
i:
  42877: acfb31f
  42875: 86ec143
  42871: 1ba5f5b
  42863: aa33ecf
  42847: 0f3aa37
  42815: b839827
  42751: cd44180
v: v3

Author: jbclements

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 53688addaa4484f1a317bb0938cf453381810427
+refs/heads/try: 4af7c643f2555d476d6ad4dc6758fafada21b084
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/libsyntax/parse/parser.rs

@@ -1456,96 +1456,105 @@ pub impl Parser {
         return self.mk_expr(lo, hi, ex);
     }
 
-
+    // parse an expression of binops
     fn parse_binops() -> @expr {
-        return self.parse_more_binops(self.parse_prefix_expr(), 0);
+        self.parse_more_binops(self.parse_prefix_expr(), 0)
     }
 
+    // parse an expression of binops of at least min_prec precedence
     fn parse_more_binops(lhs: @expr, min_prec: uint) ->
         @expr {
         if self.expr_is_complete(lhs) { return lhs; }
         let peeked = self.token;
         if peeked == token::BINOP(token::OR) &&
             (self.restriction == RESTRICT_NO_BAR_OP ||
              self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP) {
-            return lhs;
-        }
-        if peeked == token::OROR &&
+            lhs
+        } else if peeked == token::OROR &&
             self.restriction == RESTRICT_NO_BAR_OR_DOUBLEBAR_OP {
-            return lhs;
-        }
-        let cur_opt   = token_to_binop(peeked);
-        match cur_opt {
-          Some(cur_op) => {
-            let cur_prec = operator_prec(cur_op);
-            if cur_prec > min_prec {
-                self.bump();
-                let expr = self.parse_prefix_expr();
-                let rhs = self.parse_more_binops(expr, cur_prec);
-                self.get_id(); // see ast_util::op_expr_callee_id
-                let bin = self.mk_expr(lhs.span.lo, rhs.span.hi,
-                                        expr_binary(cur_op, lhs, rhs));
-                return self.parse_more_binops(bin, min_prec);
+            lhs
+        } else {
+            let cur_opt = token_to_binop(peeked);
+            match cur_opt {
+                Some(cur_op) => {
+                    let cur_prec = operator_prec(cur_op);
+                    if cur_prec > min_prec {
+                        self.bump();
+                        let expr = self.parse_prefix_expr();
+                        let rhs = self.parse_more_binops(expr, cur_prec);
+                        self.get_id(); // see ast_util::op_expr_callee_id
+                        let bin = self.mk_expr(lhs.span.lo, rhs.span.hi,
+                                               expr_binary(cur_op, lhs, rhs));
+                        self.parse_more_binops(bin, min_prec)
+                    } else {
+                        lhs
+                    }
+                }
+                None => {
+                    if as_prec > min_prec && self.eat_keyword(~"as") {
+                        let rhs = self.parse_ty(true);
+                        let _as = self.mk_expr(lhs.span.lo,
+                                               rhs.span.hi,
+                                               expr_cast(lhs, rhs));
+                        self.parse_more_binops(_as, min_prec)
+                    } else {
+                        lhs
+                    }
+                }
             }
-          }
-          _ => ()
-        }
-        if as_prec > min_prec && self.eat_keyword(~"as") {
-            let rhs = self.parse_ty(true);
-            let _as =
-                self.mk_expr(lhs.span.lo, rhs.span.hi, expr_cast(lhs, rhs));
-            return self.parse_more_binops(_as, min_prec);
         }
-        return lhs;
     }
 
-    // parse an arbitrary expression.
+    // parse an assignment expression....
+    // actually, this seems to be the main entry point for
+    // parsing an arbitrary expression.
     fn parse_assign_expr() -> @expr {
         let lo = self.span.lo;
         let lhs = self.parse_binops();
         match copy self.token {
-          token::EQ => {
-            self.bump();
-            let rhs = self.parse_expr();
-            return self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs));
+            token::EQ => {
+                self.bump();
+                let rhs = self.parse_expr();
+                self.mk_expr(lo, rhs.span.hi, expr_assign(lhs, rhs)) 
           }
           token::BINOPEQ(op) => {
-            self.bump();
-            let rhs = self.parse_expr();
-            let mut aop;
-            match op {
-              token::PLUS => aop = add,
-              token::MINUS => aop = subtract,
-              token::STAR => aop = mul,
-              token::SLASH => aop = div,
-              token::PERCENT => aop = rem,
-              token::CARET => aop = bitxor,
-              token::AND => aop = bitand,
-              token::OR => aop = bitor,
-              token::SHL => aop = shl,
-              token::SHR => aop = shr
-            }
-            self.get_id(); // see ast_util::op_expr_callee_id
-            return self.mk_expr(lo, rhs.span.hi,
-                                expr_assign_op(aop, lhs, rhs));
+              self.bump();
+              let rhs = self.parse_expr();
+              let mut aop;
+              match op {
+                  token::PLUS => aop = add,
+                  token::MINUS => aop = subtract,
+                  token::STAR => aop = mul,
+                  token::SLASH => aop = div,
+                  token::PERCENT => aop = rem,
+                  token::CARET => aop = bitxor,
+                  token::AND => aop = bitand,
+                  token::OR => aop = bitor,
+                  token::SHL => aop = shl,
+                  token::SHR => aop = shr
+              }
+              self.get_id(); // see ast_util::op_expr_callee_id
+              self.mk_expr(lo, rhs.span.hi,
+                           expr_assign_op(aop, lhs, rhs))
           }
           token::LARROW => {
               self.obsolete(copy self.span, ObsoleteBinaryMove);
               // Bogus value (but it's an error)
               self.bump(); // <-
               self.bump(); // rhs
               self.bump(); // ;
-              return self.mk_expr(lo, self.span.hi,
-                                  expr_break(None));
+              self.mk_expr(lo, self.span.hi,
+                           expr_break(None))
           }
           token::DARROW => {
             self.bump();
             let rhs = self.parse_expr();
-            return self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs));
+            self.mk_expr(lo, rhs.span.hi, expr_swap(lhs, rhs))
+          }
+          _ => {
+              lhs
           }
-          _ => {/* fall through */ }
         }
-        return lhs;
     }
 
     fn parse_if_expr() -> @expr {
@@ -1560,7 +1569,7 @@ pub impl Parser {
             hi = elexpr.span.hi;
         }
         let q = {cond: cond, then: thn, els: els, lo: lo, hi: hi};
-        return self.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els));
+        f.mk_expr(q.lo, q.hi, expr_if(q.cond, q.then, q.els))
     }
 
     fn parse_fn_expr(proto: Proto) -> @expr {
@@ -1571,8 +1580,9 @@ pub impl Parser {
         let decl = self.parse_fn_decl(|p| p.parse_arg_or_capture_item());
 
         let body = self.parse_block();
-        return self.mk_expr(lo, body.span.hi,
-                            expr_fn(proto, decl, body, @()));
+
+        self.mk_expr(lo, body.span.hi,
+                            expr_fn(proto, decl, body, capture_clause));
     }
 
     // `|args| { ... }` like in `do` expressions