ES6: Implement generator method shorthand

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 1918 matching lines @@
   }
   UNREACHABLE();
   return this->EmptyIdentifier();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT ParserBase<
     Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker,
                                      bool in_class, bool is_static, bool* ok) {
-  // TODO(arv): Add support for concise generator methods.
   ExpressionT value = this->EmptyExpression();
   bool is_get = false;
   bool is_set = false;
   bool name_is_static = false;
+  bool is_generator = allow_harmony_object_literals_ && Check(Token::MUL);
+
   Token::Value name_token = peek();
   int next_pos = peek_position();
   IdentifierT name =
       ParsePropertyName(&is_get, &is_set, &name_is_static,
                         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   if (fni_ != NULL) this->PushLiteralName(fni_, name);
 
-  if (!in_class && peek() == Token::COLON) {
+  if (!in_class && !is_generator && peek() == Token::COLON) {
     // PropertyDefinition : PropertyName ':' AssignmentExpression
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     Consume(Token::COLON);
     value = this->ParseAssignmentExpression(
         true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
-  } else if (allow_harmony_object_literals_ && peek() == Token::LPAREN) {
+  } else if (is_generator ||
+             (allow_harmony_object_literals_ && peek() == Token::LPAREN)) {
     // Concise Method
 
     if (is_static && this->IsPrototype(name)) {
       ReportMessageAt(scanner()->location(), "static_prototype");
       *ok = false;
       return this->EmptyObjectLiteralProperty();
     }
+    if (is_generator && in_class && !is_static && this->IsConstructor(name)) {
+      ReportMessageAt(scanner()->location(), "constructor_special_method");
+      *ok = false;
+      return this->EmptyObjectLiteralProperty();
+    }
 
     checker->CheckProperty(name_token, kValueProperty,
                            CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    FunctionKind kind = FunctionKind::kConciseMethod;
+    if (is_generator) {

[Dmitry Lomov (no reviews), 2014/09/18 07:43:57]

Nit: maybe the following is better:
1) add ``kConciseGeneratorMethod = kConciseMethod | kGeneratorFuction`` to
FunctionKind (to avoid static_casts)
2) Here, write:
 FunctionKind kind = is_generator ? kConciseGeneratorMethod : kConciseMethod;

[arv (Not doing code reviews), 2014/09/18 15:59:02]

Thanks. That is much better.

+      kind = static_cast<FunctionKind>(kind | FunctionKind::kGeneratorFunction);
+    }
     value = this->ParseFunctionLiteral(
         name, scanner()->location(),
         false,  // reserved words are allowed here
-        FunctionKind::kConciseMethod, RelocInfo::kNoPosition,
-        FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::NORMAL_ARITY,
+        kind, RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
+        FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
     return ParsePropertyDefinition(checker, true, true, ok);
 
   } else if (is_get || is_set) {
     // Accessor
     bool dont_care = false;
     name_token = peek();
@@ skipping 831 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