Support for shorthand object literal notation.

JerryScript-DCO-1.0-Signed-off-by: Anthony Calandra [email protected]

Author: AnthonyCalandra

jerry-core/config.h

@@ -37,9 +37,10 @@
  */
 #ifdef CONFIG_DISABLE_ES2015
 # define CONFIG_DISABLE_ES2015_ARROW_FUNCTION
-# define CONFIG_DISABLE_ES2015_CLASS
 # define CONFIG_DISABLE_ES2015_BUILTIN
+# define CONFIG_DISABLE_ES2015_CLASS
 # define CONFIG_DISABLE_ES2015_PROMISE_BUILTIN
+# define CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
 # define CONFIG_DISABLE_ES2015_TEMPLATE_STRINGS
 # define CONFIG_DISABLE_ES2015_TYPEDARRAY_BUILTIN
 #endif /* CONFIG_DISABLE_ES2015 */

jerry-core/parser/js/js-lexer.c

@@ -448,6 +448,45 @@ static const keyword_string_t * const keyword_string_list[9] =
 #undef LEXER_KEYWORD
 #undef LEXER_KEYWORD_END
 
+#ifndef CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
+/**
+ * Checks if current identifier is a keyword or reserved word.
+ *
+ * @return true - if the current identifier is a keyword or reserved word
+ *         false - otherwise
+ */
+bool
+lexer_is_identifier_keyword (parser_context_t *context_p) /**< context */
+{
+  lexer_lit_location_t *literal_p = &context_p->token.lit_location;
+
+  JERRY_ASSERT (literal_p->type == LEXER_IDENT_LITERAL);
+  JERRY_ASSERT (literal_p->length <= PARSER_MAXIMUM_IDENT_LENGTH);
+
+  if (literal_p->has_escape || literal_p->length < 2 || literal_p->length > 10)
+  {
+    return false;
+  }
+
+  const keyword_string_t *keyword_p = keyword_string_list[literal_p->length - 2];
+
+  do
+  {
+    if (literal_p->char_p[0] == keyword_p->keyword_p[0]
+        && literal_p->char_p[1] == keyword_p->keyword_p[1]
+        && memcmp (literal_p->char_p, keyword_p->keyword_p, literal_p->length) == 0)
+    {
+      return true;
+    }
+
+    keyword_p++;
+  }
+  while (keyword_p->type != LEXER_EOS);
+
+  return false;
+} /* lexer_is_identifier_keyword */
+#endif /* !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+
 /**
  * Parse identifier.
  */
@@ -1326,7 +1365,7 @@ lexer_check_colon (parser_context_t *context_p) /**< context */
           && context_p->source_p[0] == (uint8_t) LIT_CHAR_COLON);
 } /* lexer_check_colon */
 
-#ifndef CONFIG_DISABLE_ES2015_CLASS
+#if !defined (CONFIG_DISABLE_ES2015_CLASS) || !defined (CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION)
 /**
  * Checks whether the next token is a left parenthesis.
  *
@@ -1343,7 +1382,7 @@ lexer_check_left_paren (parser_context_t *context_p) /**< context */
   return (context_p->source_p < context_p->source_end_p
           && context_p->source_p[0] == (uint8_t) LIT_CHAR_LEFT_PAREN);
 } /* lexer_check_left_paren */
-#endif /* !CONFIG_DISABLE_ES2015_CLASS */
+#endif /* !CONFIG_DISABLE_ES2015_CLASS || !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
 
 #ifndef CONFIG_DISABLE_ES2015_ARROW_FUNCTION
 
@@ -2290,8 +2329,17 @@ lexer_expect_object_literal_id (parser_context_t *context_p, /**< context */
       {
         lexer_skip_spaces (context_p);
 
-        if (context_p->source_p < context_p->source_end_p
-            && context_p->source_p[0] != LIT_CHAR_COLON)
+#ifndef CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
+        bool not_end_of_literal = (context_p->source_p < context_p->source_end_p
+          && context_p->source_p[0] != LIT_CHAR_COLON
+          && context_p->source_p[0] != LIT_CHAR_RIGHT_BRACE
+          && context_p->source_p[0] != LIT_CHAR_COMMA);
+#else /* !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+        bool not_end_of_literal = (context_p->source_p < context_p->source_end_p
+          && context_p->source_p[0] != LIT_CHAR_COLON);
+#endif /* CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+
+        if (not_end_of_literal)
         {
           if (lexer_compare_raw_identifier_to_current (context_p, "get", 3))
           {

jerry-core/parser/js/js-parser-expr.c

@@ -666,6 +666,63 @@ parser_parse_object_literal (parser_context_t *context_p) /**< context */
                                          literal_index,
                                          PARSER_OBJECT_PROPERTY_VALUE);
 
+#ifndef CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
+      if (lexer_check_colon (context_p))
+      {
+        /* If there's a colon ahead, then we have { prop: val } */
+        lexer_next_token (context_p); /* Skip colon. */
+        lexer_next_token (context_p);
+        parser_parse_expression (context_p, PARSE_EXPR_NO_COMMA);
+
+        if (context_p->last_cbc_opcode == CBC_PUSH_LITERAL)
+        {
+          context_p->last_cbc_opcode = CBC_SET_LITERAL_PROPERTY;
+          context_p->last_cbc.value = literal_index;
+        }
+        else
+        {
+          parser_emit_cbc_literal (context_p, CBC_SET_PROPERTY, literal_index);
+        }
+      }
+      else if (context_p->token.lit_location.type == LEXER_IDENT_LITERAL)
+      {
+        /* If we have an identifier literal, then we have { prop } or { prop() {...} }
+           (a.k.a shorthand notation) */
+        if (lexer_check_left_paren (context_p))
+        {
+          parser_flush_cbc (context_p);
+          uint32_t status_flags = PARSER_IS_FUNCTION | PARSER_IS_FUNC_EXPRESSION | PARSER_IS_CLOSURE;
+          uint16_t function_literal_index = lexer_construct_function_object (context_p, status_flags);
+          parser_emit_cbc_literal (context_p, CBC_PUSH_LITERAL, function_literal_index);
+          lexer_next_token (context_p);
+        }
+        else
+        {
+          lexer_construct_literal_object (context_p,
+                                          &context_p->token.lit_location,
+                                          context_p->token.lit_location.type);
+          lexer_next_token (context_p);
+
+          /* We have a literal, but there is ill-formed syntax after it or it's a keyword,
+             so just error out. */
+          if ((context_p->token.type != LEXER_RIGHT_BRACE && context_p->token.type != LEXER_COMMA)
+              || lexer_is_identifier_keyword (context_p))
+          {
+            parser_raise_error (context_p, PARSER_ERR_COLON_EXPECTED);
+          }
+
+          parser_emit_cbc_literal_from_token (context_p, CBC_PUSH_LITERAL);
+        }
+
+        context_p->last_cbc_opcode = CBC_SET_LITERAL_PROPERTY;
+        context_p->last_cbc.value = literal_index;
+      }
+      else
+      {
+        /* Else, we have something that isn't a valid object literal. */
+        parser_raise_error (context_p, PARSER_ERR_COLON_EXPECTED);
+      }
+#else /* !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
       lexer_next_token (context_p);
       if (context_p->token.type != LEXER_COLON)
       {
@@ -684,6 +741,7 @@ parser_parse_object_literal (parser_context_t *context_p) /**< context */
       {
         parser_emit_cbc_literal (context_p, CBC_SET_PROPERTY, literal_index);
       }
+#endif /* CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
     }
 
     if (context_p->token.type == LEXER_RIGHT_BRACE)

jerry-core/parser/js/js-parser-internal.h

@@ -434,10 +434,15 @@ void parser_set_continues_to_current_position (parser_context_t *context_p, pars
 
 /* Lexer functions */
 
+#ifndef CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
+bool lexer_is_identifier_keyword (parser_context_t *context_p);
+#endif /* !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
 void lexer_next_token (parser_context_t *context_p);
 bool lexer_check_colon (parser_context_t *context_p);
-#ifndef CONFIG_DISABLE_ES2015_CLASS
+#if !defined (CONFIG_DISABLE_ES2015_CLASS) || !defined (CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION)
 bool lexer_check_left_paren (parser_context_t *context_p);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS || !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+#ifndef CONFIG_DISABLE_ES2015_CLASS
 void lexer_skip_empty_statements (parser_context_t *context_p);
 #endif /* !CONFIG_DISABLE_ES2015_CLASS */
 #ifndef CONFIG_DISABLE_ES2015_ARROW_FUNCTION

jerry-core/parser/js/js-parser-scanner.c

@@ -841,7 +841,16 @@ parser_scan_until (parser_context_t *context_p, /**< context */
         }
 
         lexer_next_token (context_p);
-        if (context_p->token.type != LEXER_COLON)
+
+#ifndef CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION
+        bool not_end_of_property_name = (context_p->token.type != LEXER_COLON
+          && context_p->token.type != LEXER_RIGHT_BRACE
+          && context_p->token.type != LEXER_COMMA);
+#else /* !CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+        bool not_end_of_property_name = context_p->token.type != LEXER_COLON;
+#endif /* CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION */
+
+        if (not_end_of_property_name)
         {
           parser_raise_error (context_p, PARSER_ERR_COLON_EXPECTED);
         }

jerry-core/profiles/README.md

@@ -93,5 +93,7 @@ In JerryScript all of the features are enabled by default, so an empty profile f
   Disable the [template strings](http://www.ecma-international.org/ecma-262/6.0/#sec-static-semantics-templatestrings).
 * `CONFIG_DISABLE_ES2015_TYPEDARRAY_BUILTIN`:
   Disable the [ArrayBuffer](http://www.ecma-international.org/ecma-262/6.0/#sec-arraybuffer-objects) and [TypedArray](http://www.ecma-international.org/ecma-262/6.0/#sec-typedarray-objects) built-ins.
+* `CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION`:
+  Disable the [object literal shorthand notation](https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer).
 * `CONFIG_DISABLE_ES2015`: Disable all of the implemented [ECMAScript2015 features](http://www.ecma-international.org/ecma-262/6.0/).
-  (equivalent to `CONFIG_DISABLE_ES2015_ARROW_FUNCTION`, `CONFIG_DISABLE_ES2015_BUILTIN`, `CONFIG_DISABLE_ES2015_CLASS`, `CONFIG_DISABLE_ES2015_PROMISE_BUILTIN`, `CONFIG_DISABLE_ES2015_TEMPLATE_STRINGS`, and `CONFIG_DISABLE_ES2015_TYPEDARRAY_BUILTIN`).
+  (equivalent to `CONFIG_DISABLE_ES2015_ARROW_FUNCTION`, `CONFIG_DISABLE_ES2015_BUILTIN`, `CONFIG_DISABLE_ES2015_CLASS`, `CONFIG_DISABLE_ES2015_PROMISE_BUILTIN`, `CONFIG_DISABLE_ES2015_TEMPLATE_STRINGS`, `CONFIG_DISABLE_ES2015_TYPEDARRAY_BUILTIN`, and `CONFIG_DISABLE_ES2015_SHORTHAND_OBJ_LITERAL_NOTATION`).

tests/jerry/es2015/object-literal-shorthand-notation.js

@@ -0,0 +1,68 @@
+// Copyright JS Foundation and other contributors, http://js.foundation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var x = 1, y = 2, z = 3;
+var obj = { x, y, z: { z } };
+assert(obj.x === 1);
+assert(obj.y === 2);
+assert(obj.z.z === 3);
+
+try {
+  var a = { get, set };
+  assert(false);
+} catch (e) {
+  assert(e instanceof ReferenceError);
+}
+
+function checkReservedAsVars() {
+  var get = 1, set = 2;
+  var a = { get, set };
+  assert(a.get + a.set === 3);
+}
+checkReservedAsVars();
+
+var one = 1;
+assert({ one, one }.one === 1);
+assert({ one: 0, one }.one === 1);
+assert({ one, one: 0 }.one === 0);
+
+var obj2 = { one };
+assert({ obj2 }.obj2.one === 1);
+
+try {
+  eval('({ true, false, null })');
+  assert(false);
+} catch (e) {
+  assert(e instanceof SyntaxError);
+}
+
+var obj3 = { f() { return 1; } };
+assert(obj3.f() === 1);
+
+var obj4 = { one, one() { return one; } };
+assert(typeof obj4.one === 'function');
+assert(obj4.one() === 1);
+
+var obj5 = { x: 123, getX() { return this.x; } };
+assert(obj5.getX() === 123);
+
+var obj6 = {
+  if() { return 0; }, else() { return 1; }, try() { return 2; }, catch() { return 3; },
+  finally() { return 4; }, let() { return 5; }, true() { return 6; }, false() { return 7; },
+  null() { return 8; }
+};
+assert(
+  obj6.if() + obj6.else() + obj6.try() + obj6.catch() + obj6.finally() + obj6.let() +
+  obj6.true() + obj6.false() + obj6.null() === 36
+);