Allow numbers and keywords, as well as computed expressions as class

keys

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) {

core/src/grammar.rs

@@ -431,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/parser.rs

@@ -891,18 +891,18 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn class_member(&mut self, name: OwnedSlice, is_static: bool) -> Result<ClassMember> {
+    fn class_member(&mut self, key: ClassKey, is_static: bool) -> Result<ClassMember> {
         Ok(match next!(self) {
             ParenOpen => {
-                if !is_static && name.as_str() == "constructor" {
+                if !is_static && key.is_constructor() {
                     ClassMember::Constructor {
                         params: try!(self.parameter_list()),
                         body: try!(self.block_body()),
                     }
                 } else {
                     ClassMember::Method {
                         is_static: is_static,
-                        name: name,
+                        key: key,
                         params: try!(self.parameter_list()),
                         body: try!(self.block_body()),
                     }
@@ -911,7 +911,7 @@ impl<'a> Parser<'a> {
             Operator(Assign) => {
                 ClassMember::Property {
                     is_static: is_static,
-                    name: name,
+                    key: key,
                     value: try!(self.expression(0)),
                 }
             },
@@ -937,17 +937,47 @@ impl<'a> Parser<'a> {
         let mut members = Vec::new();
 
         loop {
-            members.push(match next!(self) {
-                Identifier(name) => try!(self.class_member(name, false)),
-                Static           => {
-                    let name = expect_identifier!(self);
+            let mut token = next!(self);
+
+            let is_static = match token {
+                Static => {
+                    token = next!(self);
 
-                    try!(self.class_member(name, true))
+                    true
                 },
-                Semicolon        => continue,
-                BraceClose       => break,
-                _                => unexpected_token!(self)
-            });
+
+                _ => false
+            };
+
+            let key = match token {
+                Semicolon => continue,
+
+                BraceClose => break,
+
+                Literal(Value::Number(num)) => ClassKey::Number(num),
+
+                Literal(Value::Binary(num)) => ClassKey::Binary(num),
+
+                Identifier(key) => ClassKey::Literal(key),
+
+                BracketOpen => {
+                    let expr = try!(self.sequence_or_expression());
+
+                    expect!(self, BracketClose);
+
+                    ClassKey::Computed(expr)
+                }
+
+                _ => {
+                    // Allow word tokens such as "null" and "typeof" as identifiers
+                    match token.as_word() {
+                        Some(key) => ClassKey::Literal(key.into()),
+                        _         => unexpected_token!(self)
+                    }
+                }
+            };
+
+            members.push(try!(self.class_member(key, is_static)));
         }
 
         Ok(Statement::Class {

core/src/transformer.rs

@@ -533,14 +533,14 @@ fn add_props_to_body(body: &mut Vec<Statement>, mut props: Vec<ClassMember>) {
     for prop in props.iter_mut().rev() {
         if let &mut ClassMember::Property {
             // ref is_static,
-            ref name,
+            ref mut key,
             ref mut value,
             ..
         } = prop {
             body.insert(
                 0,
                 Expression::binary(
-                    Expression::member(Expression::This, *name),
+                    class_key_to_member(Expression::This, key),
                     Assign,
                     value.take(),
                 ).into()
@@ -549,6 +549,30 @@ fn add_props_to_body(body: &mut Vec<Statement>, mut props: Vec<ClassMember>) {
     }
 }
 
+#[inline]
+fn class_key_to_member(object: Expression, key: &mut ClassKey) -> Expression {
+    let expr = match *key {
+        ClassKey::Literal(ref name) => {
+            return Expression::member(object, *name);
+        },
+
+        ClassKey::Computed(ref mut expr) => expr.take(),
+
+        ClassKey::Number(ref num) => {
+            Expression::Literal(Value::Number(*num))
+        },
+
+        ClassKey::Binary(ref num) => {
+            Expression::Literal(Value::Binary(*num))
+        }
+    };
+
+    Expression::ComputedMember {
+        object: Box::new(object),
+        property: Box::new(expr),
+    }
+}
+
 impl Transformable for Statement {
     fn transform(&mut self, settings: &Settings) {
         *self = match *self {
@@ -671,20 +695,19 @@ impl Transformable for Statement {
 
                     for method in methods.iter_mut() {
                         if let &mut ClassMember::Method {
-                            name: ref method_name,
+                            key: ref mut method_key,
                             params: ref mut method_params,
                             body: ref mut method_body,
                             ..
                         } = method {
+                            let proto = Expression::member(name, "prototype");
+
                             body.push(
                                 Expression::binary(
-                                    Expression::member(
-                                        Expression::member(name, "prototype"),
-                                        *method_name
-                                    ),
+                                    class_key_to_member(proto, method_key),
                                     Assign,
                                     Expression::Function {
-                                        name: Some(*method_name),
+                                        name: None,
                                         params: method_params.take(),
                                         body: method_body.take(),
                                     },

core/tests/codegen.rs

@@ -32,6 +32,17 @@ fn dont_touch_var_in_global_scope() {
     assert_compile!("var pi = 3.14;", "var pi=3.14;");
 }
 
+#[test]
+fn convert_let_to_var_in_block() {
+    let program = "if(true) {
+      let pi = 3.14;
+    }";
+
+    let expected = "if(!0){var pi=3.14;}";
+
+    assert_compile!(program, expected);
+}
+
 #[test]
 fn template_strings_plain() {
     assert_compile!("`foobar`;", r#""foobar";"#);
@@ -67,14 +78,4 @@ fn template_strings_tagged() {
     assert_compile!("foo`bar${1}baz${2}`;", r#"foo(["bar","baz",""],1,2);"#);
 }
 
-#[test]
-fn convert_let_to_var_in_block() {
-    let program = "if(true) {
-      let pi = 3.14;
-    }";
-
-    let expected = "if(!0){var pi=3.14;}";
-
-    assert_compile!(program, expected);
-}