ratel-rust · maciejhirsz · Nov 3, 2016 · Oct 26, 2016 · Oct 27, 2016 · Nov 2, 2016
diff --git a/core/Cargo.toml b/core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ratel"
-version = "0.5.5"
+version = "0.6.0"
 authors = ["Maciej Hirsz <maciej.hirsz@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "JavaScript transpiler in Rust"

diff --git a/core/src/codegen.rs b/core/src/codegen.rs
@@ -320,7 +320,11 @@ impl Code for ObjectKey {
 impl Code for Parameter {
     #[inline]
     fn to_code(&self, gen: &mut Generator) {
-        gen.write_bytes(self.name.as_bytes());
+        gen.write(&self.name);
+        if let Some(ref expression) = self.default {
+            gen.write_min(b" = ", b"=");
+            gen.write(expression);
+        }
     }
 }
 

diff --git a/core/src/grammar.rs b/core/src/grammar.rs
@@ -12,10 +12,10 @@ pub enum Value {
     RawQuasi(OwnedSlice),
 }
 
-
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct Parameter {
     pub name: OwnedSlice,
+    pub default: Option<Box<Expression>>
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]

diff --git a/core/src/parser.rs b/core/src/parser.rs
@@ -271,19 +271,62 @@ impl<'a> Parser<'a> {
     fn arrow_function_expression(&mut self, p: Option<Expression>) -> Result<Expression> {
         let params: Vec<Parameter> = match p {
             None => Vec::new(),
+
             Some(Expression::Identifier(name)) => {
-                vec![Parameter { name: name }]
+                vec![Parameter {
+                    name    : name,
+                    default : None,
+                }]
             },
+
+            Some(Expression::Binary {
+                parenthesized : true,
+                operator      : Assign,
+                left,
+                right,
+            }) => {
+                let name = match *left {
+                    Expression::Identifier(value) => value,
+                    _                 => unexpected_token!(self)
+                };
+
+                vec![Parameter {
+                    name    : name,
+                    default : Some(right),
+                }]
+            },
+
             Some(Expression::Sequence(mut list)) => {
                 let mut params = Vec::with_capacity(list.len());
 
                 for expression in list.drain(..) {
-                    match expression {
+                    params.push(match expression {
+                        Expression::Binary {
+                            operator: Assign,
+                            left,
+                            right,
+                            ..
+                        } => {
+                            let name = match *left {
+                                Expression::Identifier(value) => value,
+                                _ => unexpected_token!(self)
+                            };
+
+                            Parameter {
+                                name    : name,
+                                default : Some(right),
+                            }
+                        },
+
                         Expression::Identifier(name) => {
-                            params.push(Parameter { name: name });
+                            Parameter {
+                                name    : name,
+                                default : None
+                            }
                         },
+
                         _ => unexpected_token!(self)
-                    }
+                    })
                 }
 
                 params
@@ -857,17 +900,35 @@ impl<'a> Parser<'a> {
 
     fn parameter_list(&mut self) -> Result<Vec<Parameter>> {
         let mut list = Vec::new();
+        let mut default_params = false;
 
         loop {
-            match next!(self) {
+            let name = match next!(self) {
                 ParenClose       => break,
-                Identifier(name) => {
-                    list.push(Parameter {
-                        name: name
-                    });
-                },
+                Identifier(name) => name,
                 _ => unexpected_token!(self)
-            }
+            };
+
+            list.push(match peek!(self) {
+                Operator(Assign) => {
+                    self.consume();
+                    let expression = try!(self.expression(0));
+                    default_params = true;
+                    Parameter {
+                        name: name,
+                        default: Some(Box::new(expression))
+                    }
+                }
+                _ => {
+                    if default_params {
+                        unexpected_token!(self);
+                    }
+                    Parameter {
+                        name: name,
+                        default: None
+                    }
+                }
+            });
 
             match next!(self) {
                 ParenClose => break,