Allow keywords and other words (null, new) as identifiers for objects

and property accessors

Author: maciejhirsz

core/src/codegen.rs

@@ -642,7 +642,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 {

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,
+        }
+    }
+}

core/src/parser.rs

@@ -171,81 +171,49 @@ impl<'a> Parser<'a> {
 
     #[inline]
     fn object_member(&mut self, token: Token) -> Result<ObjectMember> {
-        Ok(match token {
-
-            Identifier(key)             |
-            Literal(Value::String(key)) |
-            Literal(Value::Number(key)) => {
-
+        let key = match token {
+            Identifier(key) => {
                 match peek!(self) {
-                    Colon => {
-                        self.consume();
-                        let key = ObjectKey::Literal(key);
+                    Colon | ParenOpen => ObjectKey::Literal(key),
 
-                        ObjectMember::Value {
-                            key: key,
-                            value: try!(self.expression(0)),
-                        }
-                    },
-
-                    ParenOpen => {
-                        self.consume();
-                        let key = ObjectKey::Literal(key);
-
-                        ObjectMember::Method {
-                            key: key,
-                            params: try!(self.parameter_list()),
-                            body: try!(self.block_body())
-                        }
-                    },
-
-                    _ => ObjectMember::Shorthand {
+                    _ => return Ok(ObjectMember::Shorthand {
                         key: key,
-                    }
+                    })
                 }
             },
-            Literal(Value::Binary(num)) => {
-                let key = ObjectKey::Binary(num);
-                match peek!(self) {
-                    Colon => {
-                        self.consume();
-
-                        ObjectMember::Value {
-                            key: key,
-                            value: try!(self.expression(0)),
-                        }
-                    },
-
-                    ParenOpen => {
-                        self.consume();
 
-                        ObjectMember::Method {
-                            key: key,
-                            params: try!(self.parameter_list()),
-                            body: try!(self.block_body())
-                        }
-                    },
-
-                    _ => unexpected_token!(self)
-                }
-            },
             BracketOpen => {
                 let key = ObjectKey::Computed(try!(self.expression(0)));
 
                 expect!(self, BracketClose);
 
-                match next!(self) {
-                    Colon => ObjectMember::Value {
-                        key: key,
-                        value: try!(self.expression(0)),
-                    },
-                    ParenOpen => ObjectMember::Method {
-                        key: key,
-                        params: try!(self.parameter_list()),
-                        body: try!(self.block_body()),
-                    },
-                    _ => unexpected_token!(self)
+                key
+            },
+
+            Literal(Value::String(key)) => ObjectKey::Literal(key),
+
+            Literal(Value::Number(key)) => ObjectKey::Literal(key),
+
+            Literal(Value::Binary(num)) => ObjectKey::Binary(num),
+
+            _ => {
+                // Allow word tokens such as "null" and "typeof" as identifiers
+                match token.as_word() {
+                    Some(key) => ObjectKey::Literal(key.into()),
+                    None      => unexpected_token!(self)
                 }
+            }
+        };
+
+        Ok(match next!(self) {
+            Colon => ObjectMember::Value {
+                key: key,
+                value: try!(self.expression(0)),
+            },
+            ParenOpen => ObjectMember::Method {
+                key: key,
+                params: try!(self.parameter_list()),
+                body: try!(self.block_body()),
             },
             _ => unexpected_token!(self)
         })
@@ -358,7 +326,19 @@ impl<'a> Parser<'a> {
                 operand: Box::new(left),
             },
 
-            Accessor => Expression::member(left, expect_identifier!(self)),
+            Accessor => {
+                let ident = match next!(self) {
+                    Identifier(ident) => ident,
+
+                    // Allow word tokens such as "null" and "typeof" as identifiers
+                    token => match token.as_word() {
+                        Some(ident) => ident.into(),
+                        None        => unexpected_token!(self)
+                    },
+                };
+
+                Expression::member(left, ident)
+            },
 
             Conditional => Expression::Conditional {
                 test: Box::new(left),

core/tests/parser.rs

@@ -807,6 +807,36 @@ fn object_hex_literal_member() {
     ]));
 }
 
+#[test]
+fn object_keyword_literal_member() {
+    assert_expression!("({ function : 100})", Expression::Object(vec![
+        ObjectMember::Value {
+            key: ObjectKey::Literal("function".into()),
+            value: num!("100"),
+        }
+    ]));
+}
+
+#[test]
+fn object_value_word_literal_member() {
+    assert_expression!("({ true : 100})", Expression::Object(vec![
+        ObjectMember::Value {
+            key: ObjectKey::Literal("true".into()),
+            value: num!("100"),
+        }
+    ]));
+}
+
+#[test]
+fn object_operator_word_literal_member() {
+    assert_expression!("({ new : 100})", Expression::Object(vec![
+        ObjectMember::Value {
+            key: ObjectKey::Literal("new".into()),
+            value: num!("100"),
+        }
+    ]));
+}
+
 #[test]
 fn object_computed_member() {
     assert_expression!("({[100]:100})", Expression::Object(vec![
@@ -859,6 +889,38 @@ fn object_number_method_member() {
     ]));
 }
 
+#[test]
+fn accesss_member_identifier() {
+    assert_expression!("this.foo", Expression::Member {
+        object: Box::new(Expression::This),
+        property: "foo".into()
+    })
+}
+
+#[test]
+fn accesss_member_keyword() {
+    assert_expression!("this.function", Expression::Member {
+        object: Box::new(Expression::This),
+        property: "function".into()
+    })
+}
+
+#[test]
+fn accesss_member_value_word() {
+    assert_expression!("this.true", Expression::Member {
+        object: Box::new(Expression::This),
+        property: "true".into()
+    })
+}
+
+#[test]
+fn accesss_member_operator_word() {
+    assert_expression!("this.new", Expression::Member {
+        object: Box::new(Expression::This),
+        property: "new".into()
+    })
+}
+
 #[test]
 fn class_statement() {
     assert_statement!("class Foo {}", Statement::Class {