Merge pull request #29 from ratel-rust/keywords-as-keys

Closes #23

Author: maciejhirsz

core/Cargo.toml

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

core/src/codegen.rs

@@ -561,14 +561,14 @@ impl Code for ClassMember {
 
             ClassMember::Method {
                 is_static,
-                ref name,
+                ref key,
                 ref params,
                 ref body,
             } => {
                 if is_static {
                     gen.write_bytes(b"static ");
                 }
-                gen.write(name);
+                gen.write(key);
                 gen.write_byte(b'(');
                 gen.write_list(params);
                 gen.write_min(b") {", b"){");
@@ -578,13 +578,13 @@ impl Code for ClassMember {
 
             ClassMember::Property {
                 is_static,
-                ref name,
+                ref key,
                 ref value,
             } => {
                 if is_static {
                     gen.write_bytes(b"static ");
                 }
-                gen.write(name);
+                gen.write(key);
                 gen.write_min(b" = ", b"=");
                 gen.write(value);
                 gen.write_byte(b';');
@@ -593,6 +593,24 @@ impl Code for ClassMember {
     }
 }
 
+impl Code for ClassKey {
+    fn to_code(&self, gen: &mut Generator) {
+        match *self {
+            ClassKey::Literal(ref name)  => gen.write(name),
+
+            ClassKey::Number(ref name)   => gen.write(name),
+
+            ClassKey::Binary(ref num)    => gen.write(num),
+
+            ClassKey::Computed(ref expr) => {
+                gen.write_byte(b'[');
+                gen.write(expr);
+                gen.write_byte(b']');
+            }
+        }
+    }
+}
+
 impl Code for VariableDeclarator {
     #[inline]
     fn to_code(&self, gen: &mut Generator) {
@@ -642,7 +660,13 @@ impl Code for Statement {
             Statement::Expression {
                 ref value,
             } => {
-                gen.write(value);
+                if value.is_allowed_as_bare_statement() {
+                    gen.write(value);
+                } else {
+                    gen.write_byte(b'(');
+                    gen.write(value);
+                    gen.write_byte(b')');
+                }
                 gen.write_byte(b';');
             },
 

core/src/grammar.rs

@@ -367,6 +367,16 @@ impl Expression {
             _ => false
         }
     }
+
+    #[inline]
+    pub fn is_allowed_as_bare_statement(&self) -> bool {
+        match *self {
+            Expression::Object(_)       => false,
+            Expression::Function { .. } => false,
+
+            _                           => true,
+        }
+    }
 }
 
 impl From<&'static str> for Expression {
@@ -421,17 +431,36 @@ pub enum ClassMember {
     },
     Method {
         is_static: bool,
-        name: OwnedSlice,
+        key: ClassKey,
         params: Vec<Parameter>,
         body: Vec<Statement>,
     },
     Property {
         is_static: bool,
-        name: OwnedSlice,
+        key: ClassKey,
         value: Expression,
     }
 }
 
+#[derive(Debug, PartialEq, Clone)]
+pub enum ClassKey {
+    Computed(Expression),
+    Literal(OwnedSlice),
+    Number(OwnedSlice),
+    Binary(u64),
+}
+
+impl ClassKey {
+    #[inline]
+    pub fn is_constructor(&self) -> bool {
+        match *self {
+            ClassKey::Literal(ref name) => name.as_str() == "constructor",
+
+            _ => false
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum VariableDeclarationKind {
     Var,

core/src/lexicon.rs

@@ -65,3 +65,51 @@ pub enum Token {
     Literal(Value),
     Template(TemplateKind),
 }
+
+impl Token {
+    pub fn as_word(&self) -> Option<&'static str> {
+        use self::Token::*;
+        use grammar::OperatorType::*;
+        use grammar::Value::*;
+
+        match *self {
+            Break                => Some("break"),
+            Do                   => Some("do"),
+            Case                 => Some("case"),
+            Else                 => Some("else"),
+            Catch                => Some("catch"),
+            Export               => Some("export"),
+            Class                => Some("class"),
+            Extends              => Some("extends"),
+            Return               => Some("return"),
+            While                => Some("while"),
+            Finally              => Some("finally"),
+            Super                => Some("super"),
+            With                 => Some("with"),
+            Continue             => Some("continue"),
+            For                  => Some("for"),
+            Switch               => Some("switch"),
+            Yield                => Some("yield"),
+            Debugger             => Some("debugger"),
+            Function             => Some("function"),
+            This                 => Some("this"),
+            Default              => Some("default"),
+            If                   => Some("if"),
+            Throw                => Some("throw"),
+            Import               => Some("import"),
+            Try                  => Some("try"),
+            Static               => Some("static"),
+            Operator(New)        => Some("new"),
+            Operator(Typeof)     => Some("typeof"),
+            Operator(Void)       => Some("void"),
+            Operator(Delete)     => Some("delte"),
+            Operator(Instanceof) => Some("instanceof"),
+            Literal(True)        => Some("true"),
+            Literal(False)       => Some("false"),
+            Literal(Null)        => Some("null"),
+            Literal(Undefined)   => Some("undefined"),
+
+            _                    => None,
+        }
+    }
+}