Merge pull request #45 from ratel-rust/trycatch

Add support for try and catch, closes #35

Author: maciejhirsz

core/src/codegen.rs

@@ -838,6 +838,19 @@ impl Code for Statement {
                 gen.write_bytes(b"throw ");
                 gen.write(value);
                 gen.write_byte(b';');
+            },
+
+            Statement::Try {
+                ref body,
+                ref error,
+                ref handler,
+            } => {
+                gen.write_min(b"try ", b"try");
+                gen.write(body);
+                gen.write_min(b" catch (", b"catch(");
+                gen.write(error);
+                gen.write_min(b") ", b")");
+                gen.write(handler);
             }
         }
     }

core/src/grammar.rs

@@ -338,6 +338,11 @@ pub enum Statement {
     Throw {
         value: Expression
     },
+    Try {
+        body: Box<Statement>,
+        error: OwnedSlice,
+        handler: Box<Statement>,
+    }
 }
 
 impl From<Expression> for Statement {

core/src/parser.rs

@@ -654,11 +654,9 @@ impl<'a> Parser<'a> {
     #[inline]
     fn labeled_or_expression_statement(&mut self, label: OwnedSlice) -> Result<Statement> {
         allow!(self, Colon => {
-            let token = next!(self);
-
             return Ok(Statement::Labeled {
                 label: label,
-                body: Box::new(try!(self.statement(token)))
+                body: Box::new(try!(self.expect_statement()))
             })
         });
 
@@ -712,6 +710,25 @@ impl<'a> Parser<'a> {
         Ok(statement)
     }
 
+    fn try_statement(&mut self) -> Result<Statement> {
+        let body = try!(self.expect_statement());
+
+        expect!(self, Catch);
+        expect!(self, ParenOpen);
+
+        let error = expect_identifier!(self);
+
+        expect!(self, ParenClose);
+
+        let handler = try!(self.expect_statement());
+
+        Ok(Statement::Try {
+            body: Box::new(body),
+            error: error,
+            handler: Box::new(handler),
+        })
+    }
+
     #[inline]
     fn break_statement(&mut self) -> Result<Statement> {
         let statement = Statement::Break {
@@ -740,16 +757,13 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let token = next!(self);
-        let consequent = Box::new(try!(self.statement(token)));
+        let consequent = Box::new(try!(self.expect_statement()));
 
         let alternate = match peek!(self) {
             Else => {
                 self.consume();
 
-                let token = next!(self);
-
-                Some(Box::new(try!(self.statement(token))))
+                Some(Box::new(try!(self.expect_statement())))
             },
 
             _ => None
@@ -770,8 +784,7 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let token = next!(self);
-        let body = Box::new(try!(self.statement(token)));
+        let body = Box::new(try!(self.expect_statement()));
 
         Ok(Statement::While {
             test: test,
@@ -835,8 +848,7 @@ impl<'a> Parser<'a> {
             expect!(self, ParenClose);
         }
 
-        let token = next!(self);
-        let body = Box::new(try!(self.statement(token)));
+        let body = Box::new(try!(self.expect_statement()));
 
         Ok(Statement::For {
             init: init,
@@ -852,8 +864,7 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let token = next!(self);
-        let body = Box::new(try!(self.statement(token)));
+        let body = Box::new(try!(self.expect_statement()));
 
         Ok(Statement::ForIn {
             left: left,
@@ -867,8 +878,7 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let token = next!(self);
-        let body = Box::new(try!(self.statement(token)));
+        let body = Box::new(try!(self.expect_statement()));
 
         Ok(Statement::ForIn {
             left: left,
@@ -882,8 +892,7 @@ impl<'a> Parser<'a> {
 
         expect!(self, ParenClose);
 
-        let token = next!(self);
-        let body = Box::new(try!(self.statement(token)));
+        let body = Box::new(try!(self.expect_statement()));
 
         Ok(Statement::ForOf {
             left: left,
@@ -1048,6 +1057,13 @@ impl<'a> Parser<'a> {
         self.tokenizer.read_regular_expression()
     }
 
+    #[inline]
+    fn expect_statement(&mut self) -> Result<Statement> {
+        let token = next!(self);
+
+        self.statement(token)
+    }
+
     #[inline]
     fn statement(&mut self, token: Token) -> Result<Statement> {
         match token {
@@ -1063,6 +1079,7 @@ impl<'a> Parser<'a> {
             For                => self.for_statement(),
             Identifier(label)  => self.labeled_or_expression_statement(label),
             Throw              => self.throw_statement(),
+            Try                => self.try_statement(),
             _                  => self.expression_statement(token),
         }
     }

core/src/transformer.rs

@@ -951,6 +951,17 @@ impl Transformable for Statement {
             },
 
             Statement::Break { .. } => return,
+
+            Statement::Try {
+                ref mut body,
+                ref mut handler,
+                ..
+            } => {
+                body.transform(settings);
+                handler.transform(settings);
+
+                return;
+            },
         }
     }
 

core/tests/codegen.rs

@@ -187,3 +187,8 @@ fn object_method_default_parameters() {
 fn class_method_default_parameters() {
     assert_compile!("class Foo{bar(a,b=1){}}", "function Foo(){}Foo.prototype.bar=function(a,b){b===undefined&&(b=1);};")
 }
+
+#[test]
+fn try_catch() {
+    assert_compile!("try{foo();}catch(err){console.error(err);}", "try{foo();}catch(err){console.error(err);}");
+}

core/tests/parser.rs

@@ -1328,3 +1328,32 @@ fn regular_expression_escaping() {
         flags: "i".into()
     });
 }
+
+#[test]
+fn try_catch_statement() {
+    assert_statement!("
+
+    try {
+        true;
+    } catch (err) {
+        false;
+    }
+
+    ", Statement::Try {
+        body: Box::new(Statement::Block {
+            body: vec![
+                Statement::Expression {
+                    value: Expression::Literal(Value::True)
+                }
+            ]
+        }),
+        error: "err".into(),
+        handler: Box::new(Statement::Block {
+            body: vec![
+                Statement::Expression {
+                    value: Expression::Literal(Value::False)
+                }
+            ]
+        }),
+    });
+}