Merge pull request #186 from alexcrichton/yield

Support for `yield` expressions

Author: alexcrichton

src/expr.rs

@@ -346,6 +346,14 @@ ast_enum_of_structs! {
             pub catch_token: tokens::Catch,
             pub block: Block,
         }),
+
+        /// A yield expression.
+        ///
+        /// E.g. `yield expr`
+        pub Yield(ExprYield #full {
+            pub yield_token: tokens::Yield,
+            pub expr: Option<Box<Expr>>,
+        }),
     }
 }
 
@@ -1164,6 +1172,8 @@ pub mod parsing {
         |
         syn!(ExprCatch) => { ExprKind::Catch }
         |
+        syn!(ExprYield) => { ExprKind::Yield }
+        |
         call!(expr_closure, allow_struct)
         |
         cond_reduce!(allow_block, map!(syn!(ExprBlock), ExprKind::Block))
@@ -1208,6 +1218,8 @@ pub mod parsing {
         |
         syn!(ExprCatch) => { ExprKind::Catch }
         |
+        syn!(ExprYield) => { ExprKind::Yield }
+        |
         syn!(ExprBlock) => { ExprKind::Block }
     ), Expr::from));
 
@@ -1472,6 +1484,18 @@ pub mod parsing {
         ));
     }
 
+    #[cfg(feature = "full")]
+    impl Synom for ExprYield {
+        named!(parse -> Self, do_parse!(
+            yield_: syn!(Yield) >>
+            expr: option!(syn!(Expr)) >>
+            (ExprYield {
+                yield_token: yield_,
+                expr: expr.map(Box::new),
+            })
+        ));
+    }
+
     #[cfg(feature = "full")]
     fn arm_requires_comma(arm: &Arm) -> bool {
         if let ExprKind::Block(ExprBlock { unsafety: Unsafety::Normal, .. }) = arm.body.node {
@@ -2448,6 +2472,14 @@ mod printing {
         }
     }
 
+    #[cfg(feature = "full")]
+    impl ToTokens for ExprYield {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.yield_token.to_tokens(tokens);
+            self.expr.to_tokens(tokens);
+        }
+    }
+
     #[cfg(feature = "full")]
     impl ToTokens for ExprClosure {
         fn to_tokens(&self, tokens: &mut Tokens) {

src/fold.rs

@@ -892,6 +892,13 @@ pub fn noop_fold_expr<F: ?Sized + Folder>(folder: &mut F, Expr { node, attrs }:
                 })
             }
             #[cfg(feature = "full")]
+            Yield(e) => {
+                Yield(ExprYield {
+                    expr: e.expr.map(|e| e.lift(|e| folder.fold_expr(e))),
+                    ..e
+                })
+            }
+            #[cfg(feature = "full")]
             Closure(e) => {
                 Closure(ExprClosure {
                     decl: e.decl.lift(|v| folder.fold_fn_decl(v)),

src/visit.rs

@@ -591,6 +591,12 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr) {
             visitor.visit_expr(amt);
         }
         #[cfg(feature = "full")]
+        Yield(ExprYield { ref expr, .. }) => {
+            if let Some(ref expr) = *expr {
+                visitor.visit_expr(expr);
+            }
+        }
+        #[cfg(feature = "full")]
         TupField(ExprTupField { ref expr, .. }) |
         Unary(ExprUnary { ref expr, .. }) |
         Box(ExprBox { ref expr, .. }) |

synom/src/tokens.rs

@@ -190,6 +190,7 @@ tokens! {
         (pub struct Use                     => "use"),
         (pub struct Where                   => "where"),
         (pub struct While                   => "while"),
+        (pub struct Yield                   => "yield"),
     }
 }