ES6: Add support for method shorthand in object literals

src/parser.h

Index: src/parser.h
diff --git a/src/parser.h b/src/parser.h
index 4aa6f719f3b9361d7cf6a1622f4cc7cc8dd0f908..162dbffe5b237564f8fc4362cb246187371ab053 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -572,14 +572,13 @@ class ParserTraits {
   // 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);
@@ -733,14 +732,13 @@ class Parser : public ParserBase<ParserTraits> {
       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);