Teach libsyntax about if let

Author: lilyball

src/libsyntax/ast.rs

@@ -534,6 +534,7 @@ pub enum Expr_ {
     ExprLit(Gc<Lit>),
     ExprCast(Gc<Expr>, P<Ty>),
     ExprIf(Gc<Expr>, P<Block>, Option<Gc<Expr>>),
+    ExprIfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
     ExprWhile(Gc<Expr>, P<Block>),
     // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.
     ExprForLoop(Gc<Pat>, Gc<Expr>, P<Block>, Option<Ident>),

src/libsyntax/fold.rs

@@ -1129,6 +1129,12 @@ pub fn noop_fold_expr<T: Folder>(e: Gc<Expr>, folder: &mut T) -> Gc<Expr> {
                    folder.fold_block(tr),
                    fl.map(|x| folder.fold_expr(x)))
         }
+        ExprIfLet(pat, expr, tr, fl) => {
+            ExprIfLet(folder.fold_pat(pat),
+                      folder.fold_expr(expr),
+                      folder.fold_block(tr),
+                      fl.map(|x| folder.fold_expr(x)))
+        }
         ExprWhile(cond, body) => {
             ExprWhile(folder.fold_expr(cond), folder.fold_block(body))
         }

src/libsyntax/parse/classify.rs

@@ -25,6 +25,7 @@ use std::gc::Gc;
 pub fn expr_requires_semi_to_be_stmt(e: Gc<ast::Expr>) -> bool {
     match e.node {
         ast::ExprIf(..)
+        | ast::ExprIfLet(..)
         | ast::ExprMatch(..)
         | ast::ExprBlock(_)
         | ast::ExprWhile(..)

src/libsyntax/parse/parser.rs

@@ -23,7 +23,7 @@ use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, Explicit
 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
 use ast::{ExprBreak, ExprCall, ExprCast};
-use ast::{ExprField, ExprFnBlock, ExprIf, ExprIndex};
+use ast::{ExprField, ExprFnBlock, ExprIf, ExprIfLet, ExprIndex};
 use ast::{ExprLit, ExprLoop, ExprMac};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc};
 use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary, ExprUnboxedFn};
@@ -569,13 +569,10 @@ impl<'a> Parser<'a> {
     /// If the next token is the given keyword, eat it and return
     /// true. Otherwise, return false.
     pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> bool {
-        match self.token {
-            token::IDENT(sid, false) if kw.to_name() == sid.name => {
-                self.bump();
-                true
-            }
-            _ => false
-        }
+        if self.is_keyword(kw) {
+            self.bump();
+            true
+        } else { false }
     }
 
     /// If the given word is not a keyword, signal an error.
@@ -2714,8 +2711,11 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Parse an 'if' expression ('if' token already eaten)
+    /// Parse an 'if' or 'if let' expression ('if' token already eaten)
     pub fn parse_if_expr(&mut self) -> Gc<Expr> {
+        if self.is_keyword(keywords::Let) {
+            return self.parse_if_let_expr();
+        }
         let lo = self.last_span.lo;
         let cond = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
         let thn = self.parse_block();
@@ -2729,6 +2729,21 @@ impl<'a> Parser<'a> {
         self.mk_expr(lo, hi, ExprIf(cond, thn, els))
     }
 
+    /// Parse an 'if let' expression ('if' token already eaten)
+    pub fn parse_if_let_expr(&mut self) -> Gc<Expr> {
+        let lo = self.last_span.lo;
+        self.expect_keyword(keywords::Let);
+        let pat = self.parse_pat();
+        self.expect(&token::EQ);
+        let expr = self.parse_expr_res(RESTRICT_NO_STRUCT_LITERAL);
+        let thn = self.parse_block();
+        let els = if self.eat_keyword(keywords::Else) {
+            Some(self.parse_else_expr())
+        } else { None };
+        let hi = els.map_or(thn.span.hi, |expr| expr.span.hi);
+        self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els))
+    }
+
     // `|args| expr`
     pub fn parse_lambda_expr(&mut self, capture_clause: CaptureClause)
                              -> Gc<Expr> {

src/libsyntax/print/pprust.rs

@@ -1281,6 +1281,19 @@ impl<'a> State<'a> {
                         try!(self.print_block(&**t));
                         self.print_else(e)
                     }
+                    // "another else-if-let"
+                    ast::ExprIfLet(ref pat, ref expr, ref blk, elseopt) => {
+                        try!(self.cbox(indent_unit - 1u));
+                        try!(self.ibox(0u));
+                        try!(word(&mut self.s, " else if let "));
+                        try!(self.print_pat(&**pat));
+                        try!(space(&mut self.s));
+                        try!(self.word_space("="));
+                        try!(self.print_expr(&**expr));
+                        try!(space(&mut self.s));
+                        try!(self.print_block(&**blk));
+                        self.print_else(elseopt)
+                    }
                     // "final else"
                     ast::ExprBlock(ref b) => {
                         try!(self.cbox(indent_unit - 1u));
@@ -1299,15 +1312,26 @@ impl<'a> State<'a> {
     }
 
     pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
-                    elseopt: Option<Gc<ast::Expr>>, chk: bool) -> IoResult<()> {
+                    elseopt: Option<Gc<ast::Expr>>) -> IoResult<()> {
         try!(self.head("if"));
-        if chk { try!(self.word_nbsp("check")); }
         try!(self.print_expr(test));
         try!(space(&mut self.s));
         try!(self.print_block(blk));
         self.print_else(elseopt)
     }
 
+    pub fn print_if_let(&mut self, pat: &ast::Pat, expr: &ast::Expr, blk: &ast::Block,
+                        elseopt: Option<P<ast::Expr>>) -> IoResult<()> {
+        try!(self.head("if let"));
+        try!(self.print_pat(pat));
+        try!(space(&mut self.s));
+        try!(self.word_space("="));
+        try!(self.print_expr(expr));
+        try!(space(&mut self.s));
+        try!(self.print_block(blk));
+        self.print_else(elseopt)
+    }
+
     pub fn print_mac(&mut self, m: &ast::Mac) -> IoResult<()> {
         match m.node {
             // I think it's reasonable to hide the ctxt here:
@@ -1462,7 +1486,10 @@ impl<'a> State<'a> {
                 try!(self.print_type(&**ty));
             }
             ast::ExprIf(ref test, ref blk, elseopt) => {
-                try!(self.print_if(&**test, &**blk, elseopt, false));
+                try!(self.print_if(&**test, &**blk, elseopt));
+            }
+            ast::ExprIfLet(ref pat, ref expr, ref blk, elseopt) => {
+                try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt));
             }
             ast::ExprWhile(ref test, ref blk) => {
                 try!(self.head("while"));

src/libsyntax/visit.rs

@@ -784,6 +784,12 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
             visitor.visit_block(&**if_block, env.clone());
             walk_expr_opt(visitor, optional_else, env.clone())
         }
+        ExprIfLet(ref pattern, ref subexpression, ref if_block, optional_else) => {
+            visitor.visit_pat(&**pattern, env.clone());
+            visitor.visit_expr(&**subexpression, env.clone());
+            visitor.visit_block(&**if_block, env.clone());
+            walk_expr_opt(visitor, optional_else, env.clone())
+        }
         ExprWhile(ref subexpression, ref block) => {
             visitor.visit_expr(&**subexpression, env.clone());
             visitor.visit_block(&**block, env.clone())