Merge pull request #33 from ratel-rust/for_loops

Adding support for if/for/while statements w/o body

Author: maciejhirsz

core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ratel"
-version = "0.6.1"
+version = "0.6.2"
 authors = ["Maciej Hirsz <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "JavaScript transpiler in Rust"

core/src/codegen.rs

@@ -679,6 +679,10 @@ impl Code for Statement {
                 }
             },
 
+            Statement::Empty => {
+                gen.write_byte(b';');
+            }
+
             Statement::Expression {
                 ref value,
             } => {
@@ -771,7 +775,7 @@ impl Code for Statement {
                 if let Some(ref alternate) = *alternate {
                     gen.write_bytes(b" else ");
                     gen.write(alternate);
-                };
+                }
             },
 
             Statement::While {

core/src/grammar.rs

@@ -273,6 +273,7 @@ pub struct VariableDeclarator {
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum Statement {
+    Empty,
     Block {
         body: Vec<Statement>,
     },

core/src/parser.rs

@@ -225,23 +225,6 @@ impl<'a> Parser<'a> {
         Ok(Expression::Object(try!(self.object_member_list())))
     }
 
-    #[inline]
-    fn block_or_statement(&mut self) -> Result<Statement> {
-        match peek!(self) {
-            BraceOpen => {
-                self.consume();
-
-                Ok(Statement::Block {
-                    body: try!(self.block_body_tail())
-                })
-            },
-            _ => {
-                let token = next!(self);
-                self.expression_statement(token)
-            }
-        }
-    }
-
     #[inline]
     fn block_statement(&mut self) -> Result<Statement> {
         Ok(Statement::Block {
@@ -757,21 +740,16 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let consequent = Box::new(try!(self.block_or_statement()));
+        let token = next!(self);
+        let consequent = Box::new(try!(self.statement(token)));
 
         let alternate = match peek!(self) {
             Else => {
                 self.consume();
 
-                match peek!(self) {
-                    If => {
-                        self.consume();
-
-                        Some(Box::new(try!(self.if_statement())))
-                    },
+                let token = next!(self);
 
-                    _ => Some(Box::new(try!(self.block_or_statement())))
-                }
+                Some(Box::new(try!(self.statement(token))))
             },
 
             _ => None
@@ -792,9 +770,12 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
+        let token = next!(self);
+        let body = Box::new(try!(self.statement(token)));
+
         Ok(Statement::While {
             test: test,
-            body: Box::new(try!(self.block_or_statement())),
+            body: body,
         })
     }
 
@@ -854,11 +835,14 @@ impl<'a> Parser<'a> {
             expect!(self, ParenClose);
         }
 
+        let token = next!(self);
+        let body = Box::new(try!(self.statement(token)));
+
         Ok(Statement::For {
             init: init,
             test: test,
             update: update,
-            body: Box::new(try!(self.block_or_statement())),
+            body: body,
         })
     }
 
@@ -868,10 +852,13 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
+        let token = next!(self);
+        let body = Box::new(try!(self.statement(token)));
+
         Ok(Statement::ForIn {
             left: left,
             right: right,
-            body: Box::new(try!(self.block_or_statement())),
+            body: body,
         })
     }
 
@@ -880,10 +867,13 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
+        let token = next!(self);
+        let body = Box::new(try!(self.statement(token)));
+
         Ok(Statement::ForIn {
             left: left,
             right: right,
-            body: Box::new(try!(self.block_or_statement())),
+            body: body,
         })
     }
 
@@ -892,10 +882,13 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
+        let token = next!(self);
+        let body = Box::new(try!(self.statement(token)));
+
         Ok(Statement::ForOf {
             left: left,
             right: right,
-            body: Box::new(try!(self.block_or_statement())),
+            body: body,
         })
     }
 
@@ -1058,7 +1051,7 @@ impl<'a> Parser<'a> {
     #[inline]
     fn statement(&mut self, token: Token) -> Result<Statement> {
         match token {
-            Semicolon          => Ok(Statement::Transparent { body: Vec::new() }),
+            Semicolon          => Ok(Statement::Empty),
             BraceOpen          => self.block_statement(),
             Declaration(kind)  => self.variable_declaration_statement(kind),
             Return             => self.return_statement(),

core/src/transformer.rs

@@ -888,6 +888,10 @@ impl Transformable for Statement {
                 return;
             },
 
+            Statement::Empty => {
+                return;
+            },
+
             Statement::Return {
                 ref mut value,
             } => {