ES6: Add support for method shorthand in object literals

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // For CachedDataMode
@@ skipping 554 matching lines @@
 
   // Utility functions
   int DeclareArrowParametersFromExpression(Expression* expression, Scope* scope,
                                            Scanner::Location* dupe_loc,
                                            bool* ok);
   V8_INLINE AstValueFactory* ast_value_factory();
 
   // Temporary glue; these functions will move to ParserBase.
   Expression* ParseV8Intrinsic(bool* ok);
   FunctionLiteral* ParseFunctionLiteral(
-      const AstRawString* name,
-      Scanner::Location function_name_location,
+      const AstRawString* 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,

[marja, 2014/08/22 08:22:46]

Are these flag mutually exclusive; Afaik an arrow function cannot be a
generator, so, it would make sense to have a three-value flag (normal, arrow,
generator) instead of 2 bools.

How does IsConcise relate to them? Looks like it cannot be an arrow function and
it cannot be a generator either?

So would it make sense to have a 4-value flag (normal, arrow, generator,
concise) here?

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

Generator methods can be concise, too. But that's the only possible overlap,
AFAICT. It's probably better to just extend the existing function kind enum with
both ConciseMethod and ConciseGeneratorMethod, because that's clearer and
excludes all invalid combinations by construction. (Although, in fact, there
doesn't even seem to be much of a need for distinguishing generators from
concise generators at all, so perhaps we can just completely avoid making that a
separate case.)

Likewise, it would make sense to change SharedFunctionInfo, FastNewClosureStub
and other relevant places to also use this enum instead of separate flags (in
particular, the stub will eventually need to handle arrow functions as well).

(Alternatively, we should at least have assertions in various places that
exclude all invalid combinations of the separated flags.)

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

I initially added kConciseMethod to FunctionLiteral::KindFlag but after
realizing that we will eventually need concise generator methods I changed to
individual flags.

Adding a kConciseGeneratorMethod when we need it seems like a cleaner solution.
I was not happy adding all these bool like parameters.

Looking forward, it seems like ES7 will support async functions, async arrows as
well as async concise functions and maybe even async generators. At that point
we would need to go back to individual flags but we can deal with that then.

+      FunctionLiteral::IsArrowFlag is_arrow,
+      FunctionLiteral::IsConciseMethodFlag is_concise_method,
+      int function_token_position, FunctionLiteral::FunctionType type,
+      FunctionLiteral::ArityRestriction arity_restriction, bool* ok);
   V8_INLINE void SkipLazyFunctionBody(const AstRawString* name,
                                       int* materialized_literal_count,
                                       int* expected_property_count, bool* ok);
   V8_INLINE ZoneList<Statement*>* ParseEagerFunctionBody(
       const AstRawString* name, int pos, Variable* fvar,
       Token::Value fvar_init_op, bool is_generator, bool* ok);
   V8_INLINE void CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                  bool* ok);
 
  private:
@@ skipping 133 matching lines @@
   void InitializeForEachStatement(ForEachStatement* stmt,
                                   Expression* each,
                                   Expression* subject,
                                   Statement* body);
   Statement* DesugarLetBindingsInForStatement(
       Scope* inner_scope, ZoneList<const AstRawString*>* names,
       ForStatement* loop, Statement* init, Expression* cond, Statement* next,
       Statement* body, bool* ok);
 
   FunctionLiteral* ParseFunctionLiteral(
-      const AstRawString* name,
-      Scanner::Location function_name_location,
+      const AstRawString* 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);
 
   // Magical syntax support.
   Expression* ParseV8Intrinsic(bool* ok);
 
   bool CheckInOrOf(bool accept_OF, ForEachStatement::VisitMode* visit_mode);
 
   // Get odd-ball literals.
   Literal* GetLiteralUndefined(int position);
 
   // For harmony block scoping mode: Check if the scope has conflicting var/let
@@ skipping 136 matching lines @@
  private:
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_