ES6: Add support for method shorthand in object literals

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/func-name-inferrer.h"
@@ skipping 66 matching lines @@
         fni_(NULL),
         log_(log),
         mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         scanner_(scanner),
         stack_limit_(stack_limit),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_syntax_(false),
         allow_generators_(false),
         allow_arrow_functions_(false),
+        allow_harmony_object_literals_(false),
         zone_(zone) {}
 
   // Getters that indicate whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   bool allow_lazy() const { return allow_lazy_; }
   bool allow_natives_syntax() const { return allow_natives_syntax_; }
   bool allow_generators() const { return allow_generators_; }
   bool allow_arrow_functions() const { return allow_arrow_functions_; }
   bool allow_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_scoping() const { return scanner()->HarmonyScoping(); }
   bool allow_harmony_numeric_literals() const {
     return scanner()->HarmonyNumericLiterals();
   }
   bool allow_classes() const { return scanner()->HarmonyClasses(); }
+  bool allow_harmony_object_literals() const {
+    return allow_harmony_object_literals_;
+  }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   void set_allow_natives_syntax(bool allow) { allow_natives_syntax_ = allow; }
   void set_allow_generators(bool allow) { allow_generators_ = allow; }
   void set_allow_arrow_functions(bool allow) { allow_arrow_functions_ = allow; }
   void set_allow_modules(bool allow) { scanner()->SetHarmonyModules(allow); }
   void set_allow_harmony_scoping(bool allow) {
     scanner()->SetHarmonyScoping(allow);
   }
   void set_allow_harmony_numeric_literals(bool allow) {
     scanner()->SetHarmonyNumericLiterals(allow);
   }
-  void set_allow_classes(bool allow) {
-    scanner()->SetHarmonyClasses(allow);
+  void set_allow_classes(bool allow) { scanner()->SetHarmonyClasses(allow); }
+  void set_allow_harmony_object_literals(bool allow) {
+    allow_harmony_object_literals_ = allow;
   }
 
  protected:
   friend class Traits::Checkpoint;
 
   enum AllowEvalOrArgumentsAsIdentifier {
     kAllowEvalOrArguments,
     kDontAllowEvalOrArguments
   };
 
@@ skipping 440 matching lines @@
 
  private:
   Scanner* scanner_;
   uintptr_t stack_limit_;
   bool stack_overflow_;
 
   bool allow_lazy_;
   bool allow_natives_syntax_;
   bool allow_generators_;
   bool allow_arrow_functions_;
+  bool allow_harmony_object_literals_;
 
   typename Traits::Type::Zone* zone_;  // Only used by Parser.
 };
 
 
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
@@ skipping 455 matching lines @@
   }
   PreParserExpression NewFunctionLiteral(
       PreParserIdentifier name, AstValueFactory* ast_value_factory,
       const PreParserScope& scope, PreParserStatementList body,
       int materialized_literal_count, int expected_property_count,
       int handler_count, int parameter_count,
       FunctionLiteral::ParameterFlag has_duplicate_parameters,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::IsFunctionFlag is_function,
       FunctionLiteral::IsParenthesizedFlag is_parenthesized,
-      FunctionLiteral::KindFlag kind, int position) {
+      FunctionLiteral::IsGeneratorFlag is_generator,
+      FunctionLiteral::IsArrowFlag is_arrow,
+      FunctionLiteral::IsConciseMethodFlag is_concise_method, int position) {
     return PreParserExpression::Default();
   }
 
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
   PreParserFactory* visitor() { return this; }
   BailoutReason dont_optimize_reason() { return kNoReason; }
   int* ast_properties() {
     static int dummy = 42;
     return &dummy;
@@ skipping 254 matching lines @@
     return 0;
   }
 
   static AstValueFactory* ast_value_factory() { return NULL; }
 
   void CheckConflictingVarDeclarations(PreParserScope scope, bool* ok) {}
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
-      PreParserIdentifier name,
-      Scanner::Location function_name_location,
+      PreParserIdentifier name, Scanner::Location function_name_location,
       bool name_is_strict_reserved,
-      bool is_generator,
-      int function_token_position,
-      FunctionLiteral::FunctionType type,
-      FunctionLiteral::ArityRestriction arity_restriction,
-      bool* ok);
+      FunctionLiteral::IsGeneratorFlag is_generator,
+      FunctionLiteral::IsArrowFlag is_arrow,
+      FunctionLiteral::IsConciseMethodFlag is_concise_method,
+      int function_token_position, FunctionLiteral::FunctionType type,
+      FunctionLiteral::ArityRestriction arity_restriction, bool* ok);
 
  private:
   PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
@@ skipping 110 matching lines @@
 
   V8_INLINE void SkipLazyFunctionBody(PreParserIdentifier function_name,
                                       int* materialized_literal_count,
                                       int* expected_property_count, bool* ok);
   V8_INLINE PreParserStatementList
       ParseEagerFunctionBody(PreParserIdentifier function_name, int pos,
                              Variable* fvar, Token::Value fvar_init_op,
                              bool is_generator, bool* ok);
 
   Expression ParseFunctionLiteral(
-      Identifier name,
-      Scanner::Location function_name_location,
+      Identifier name, Scanner::Location function_name_location,
       bool name_is_strict_reserved,
-      bool is_generator,
-      int function_token_pos,
-      FunctionLiteral::FunctionType function_type,
-      FunctionLiteral::ArityRestriction arity_restriction,
-      bool* ok);
+      FunctionLiteral::IsGeneratorFlag is_generator,
+      FunctionLiteral::IsArrowFlag is_arrow,
+      FunctionLiteral::IsConciseMethodFlag is_concise_method,
+      int function_token_pos, FunctionLiteral::FunctionType function_type,
+      FunctionLiteral::ArityRestriction arity_restriction, bool* ok);
   void ParseLazyFunctionLiteralBody(bool* ok);
 
   bool CheckInOrOf(bool accept_OF);
 };
 
 
 PreParserStatementList PreParser::ParseEagerFunctionBody(
     PreParserIdentifier function_name, int pos, Variable* fvar,
     Token::Value fvar_init_op, bool is_generator, bool* ok) {
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
@@ skipping 365 matching lines @@
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT ParserBase<
     Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker, bool* ok) {
   LiteralT key = this->EmptyLiteral();
   Token::Value next = peek();
   int next_pos = peek_position();
 
   switch (next) {

[rossberg, 2014/08/22 09:34:31]

Perhaps add a TODO that if both harmony_object_literals and harmony_generators
is active, you need to allow for a '*' before this.

[arv (Not doing code reviews), 2014/08/22 23:16:02]

Done.

I already have changes coming that changes this function further to handle class
elements correctly. I also plan to add support for `*method()`s.

     case Token::STRING: {
       Consume(Token::STRING);
       IdentifierT string = this->GetSymbol(scanner_);
       if (fni_ != NULL) this->PushLiteralName(fni_, string);
       uint32_t index;
       if (this->IsArrayIndex(string, &index)) {
         key = factory()->NewNumberLiteral(index, next_pos);
         break;
       }
       key = factory()->NewStringLiteral(string, next_pos);
       break;
     }
     case Token::NUMBER: {
       Consume(Token::NUMBER);
       key = this->ExpressionFromLiteral(Token::NUMBER, next_pos, scanner_,
                                         factory());
       break;
     }
     default: {
       bool is_getter = false;
       bool is_setter = false;
       IdentifierT id = ParseIdentifierNameOrGetOrSet(
           &is_getter, &is_setter, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       if (fni_ != NULL) this->PushLiteralName(fni_, id);
 
-      if ((is_getter || is_setter) && peek() != Token::COLON) {
+      if ((is_getter || is_setter) && peek() != Token::COLON &&
+          (!allow_harmony_object_literals_ || peek() != Token::LPAREN)) {
         // Special handling of getter and setter syntax:
         // { ... , get foo() { ... }, ... , set foo(v) { ... v ... } , ... }
         // We have already read the "get" or "set" keyword.
         IdentifierT name = this->EmptyIdentifier();
         switch (peek()) {
           case Token::STRING:
             Consume(Token::STRING);
             name = this->GetSymbol(scanner_);
             break;
           case Token::NUMBER:
             Consume(Token::NUMBER);
             // TODO(arv): Fix issue with numeric keys. get 1.0() should be
-            // treated as if the key was '1'
+            // treated as if the key was '1'.
             // https://code.google.com/p/v8/issues/detail?id=3507
             name = this->GetSymbol(scanner_);
             break;
           default:
             name = ParseIdentifierName(
                 CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         }
         // Validate the property.
         PropertyKind type = is_getter ? kGetterProperty : kSetterProperty;
         checker->CheckProperty(next, type,
                                CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         typename Traits::Type::FunctionLiteral value =
             this->ParseFunctionLiteral(
                 name, scanner()->location(),
                 false,  // reserved words are allowed here
-                false,  // not a generator
-                RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
+                FunctionLiteral::kNotGenerator, FunctionLiteral::kNotArrow,
+                FunctionLiteral::kNotConciseMethod, RelocInfo::kNoPosition,
+                FunctionLiteral::ANONYMOUS_EXPRESSION,
                 is_getter ? FunctionLiteral::GETTER_ARITY
                           : FunctionLiteral::SETTER_ARITY,
                 CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
         return factory()->NewObjectLiteralProperty(is_getter, value, next_pos);
       }
       // Failed to parse as get/set property, so it's just a normal property
       // (which might be called "get" or "set" or something else).
       key = factory()->NewStringLiteral(id, next_pos);
     }
   }
 
   // Validate the property
   checker->CheckProperty(next, kValueProperty,
                          CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
-  Expect(Token::COLON, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-  ExpressionT value = this->ParseAssignmentExpression(
-      true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+  ExpressionT value = this->EmptyExpression();
+
+  if (allow_harmony_object_literals_ && peek() == Token::LPAREN) {
+    // TODO(arv): If the FunctionBody references super we need to call
+    // MakeMethod.
+
+    // TODO(arv): Fix issue with numeric keys. 1.0() should be treated as if the
+    // key was '1'.
+    // https://code.google.com/p/v8/issues/detail?id=3507
+    IdentifierT name = this->GetSymbol(scanner());
+
+    value = this->ParseFunctionLiteral(
+        name, scanner()->location(),
+        false,  // reserved words are allowed here
+        FunctionLiteral::kNotGenerator, FunctionLiteral::kNotArrow,
+        FunctionLiteral::kIsConciseMethod, RelocInfo::kNoPosition,
+        FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::NORMAL_ARITY,
+        CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+  } else {
+    Expect(Token::COLON, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    value = this->ParseAssignmentExpression(
+        true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+  }
 
   return factory()->NewObjectLiteralProperty(key, value);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
     bool* ok) {
   // ObjectLiteral ::
   // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
@@ skipping 478 matching lines @@
     bool is_strict_reserved_name = false;
     Scanner::Location function_name_location = Scanner::Location::invalid();
     FunctionLiteral::FunctionType function_type =
         FunctionLiteral::ANONYMOUS_EXPRESSION;
     if (peek_any_identifier()) {
       name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                  CHECK_OK);
       function_name_location = scanner()->location();
       function_type = FunctionLiteral::NAMED_EXPRESSION;
     }
-    result = this->ParseFunctionLiteral(name,
-                                        function_name_location,
-                                        is_strict_reserved_name,
-                                        is_generator,
-                                        function_token_position,
-                                        function_type,
-                                        FunctionLiteral::NORMAL_ARITY,
-                                        CHECK_OK);
+    result = this->ParseFunctionLiteral(
+        name, function_name_location, is_strict_reserved_name,
+        is_generator ? FunctionLiteral::kIsGenerator
+                     : FunctionLiteral::kNotGenerator,
+        FunctionLiteral::kNotArrow, FunctionLiteral::kNotConciseMethod,
+        function_token_position, function_type, FunctionLiteral::NORMAL_ARITY,
+        CHECK_OK);
   } else if (peek() == Token::SUPER) {
     int beg_pos = position();
     Consume(Token::SUPER);
     Token::Value next = peek();
     if (next == Token::PERIOD || next == Token::LBRACK ||
         next == Token::LPAREN) {
       result = this->SuperReference(scope_, factory());
     } else {
       ReportMessageAt(Scanner::Location(beg_pos, position()),
                       "unexpected_super");
@@ skipping 140 matching lines @@
 
     ast_properties = *factory()->visitor()->ast_properties();
     dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
   }
 
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
       this->EmptyIdentifierString(), this->ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
-      FunctionLiteral::kNotParenthesized, FunctionLiteral::kArrowFunction,
-      start_pos);
+      FunctionLiteral::kNotParenthesized, FunctionLiteral::kNotGenerator,
+      FunctionLiteral::kIsArrow, FunctionLiteral::kNotConciseMethod, start_pos);
 
   function_literal->set_function_token_position(start_pos);
   function_literal->set_ast_properties(&ast_properties);
   function_literal->set_dont_optimize_reason(dont_optimize_reason);
 
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
 
   return function_literal;
 }
 
@@ skipping 50 matching lines @@
       DCHECK(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H