ES6: Implement generator method shorthand

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3393 matching lines @@
 
   static const ParserFlag always_flags[] = {kAllowClasses};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(NoErrorsMethodDefinition) {
   const char* context_data[][2] = {{"({", "});"},
                                    {"'use strict'; ({", "});"},
+                                   {"({*", "});"},
+                                   {"'use strict'; ({*", "});"},
                                    {NULL, NULL}};
 
   const char* object_literal_body_data[] = {
     "m() {}",
     "m(x) { return x; }",
     "m(x, y) {}, n() {}",
     "set(x, y) {}",
     "get(x, y) {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
   RunParserSyncTest(context_data, object_literal_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(MethodDefinitionNames) {
   const char* context_data[][2] = {{"({", "(x, y) {}});"},
                                    {"'use strict'; ({", "(x, y) {}});"},
+                                   {"({*", "(x, y) {}});"},
+                                   {"'use strict'; ({*", "(x, y) {}});"},
                                    {NULL, NULL}};
 
   const char* name_data[] = {
     "m",
     "'m'",
     "\"m\"",
     "\"m n\"",
     "true",
     "false",
     "null",
@@ skipping 54 matching lines @@
 
   static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
   RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 TEST(MethodDefinitionStrictFormalParamereters) {
   const char* context_data[][2] = {{"({method(", "){}});"},
                                    {"'use strict'; ({method(", "){}});"},
+                                   {"({*method(", "){}});"},
+                                   {"'use strict'; ({*method(", "){}});"},
                                    {NULL, NULL}};
 
   const char* params_data[] = {
     "x, x",
     "x, y, x",
     "eval",
     "arguments",
     "var",
     "const",
     NULL
@@ skipping 15 matching lines @@
     "x: 1, x() {}",
     "x() {}, x: 1",
     "x() {}, get x() {}",
     "x() {}, set x(_) {}",
     "x() {}, x() {}",
     "x() {}, y() {}, x() {}",
     "x() {}, \"x\"() {}",
     "x() {}, 'x'() {}",
     "0() {}, '0'() {}",
     "1.0() {}, 1: 1",
+
+    "x: 1, *x() {}",
+    "*x() {}, x: 1",
+    "*x() {}, get x() {}",
+    "*x() {}, set x(_) {}",
+    "*x() {}, *x() {}",
+    "*x() {}, y() {}, *x() {}",
+    "*x() {}, *\"x\"() {}",
+    "*x() {}, *'x'() {}",
+    "*0() {}, *'0'() {}",
+    "*1.0() {}, 1: 1",
+
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
   RunParserSyncTest(context_data, params_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(NoErrorsClassExpression) {
+TEST(ClassExpressionNoErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class {}",
     "class name {}",
     "class extends F {}",
     "class name extends F {}",
     "class extends (F, G) {}",
     "class name extends (F, G) {}",
     "class extends class {} {}",
     "class name extends class {} {}",
     "class extends class base {} {}",
     "class name extends class base {} {}",
     NULL};
 
   static const ParserFlag always_flags[] = {kAllowClasses};
   RunParserSyncTest(context_data, class_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(NoErrorsClassDeclaration) {
+TEST(ClassDeclarationNoErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
                                    {"if (true) {", "}"},
                                    {NULL, NULL}};
   const char* statement_data[] = {
     "class name {}",
     "class name extends F {}",
     "class name extends (F, G) {}",
     "class name extends class {} {}",
     "class name extends class base {} {}",
     NULL};
 
   static const ParserFlag always_flags[] = {kAllowClasses};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(NoErrorsClassBody) {
+TEST(ClassBodyNoErrors) {
   // Tests that parser and preparser accept valid class syntax.
   const char* context_data[][2] = {{"(class {", "});"},
                                    {"(class extends Base {", "});"},
                                    {"class C {", "}"},
                                    {"class C extends Base {", "}"},
                                    {NULL, NULL}};
   const char* class_body_data[] = {
     ";",
     ";;",
     "m() {}",
     "m() {};",
-    ";m() {}",
+    "; m() {}",
     "m() {}; n(x) {}",
     "get x() {}",
     "set x(v) {}",
     "get() {}",
     "set() {}",
+    "*g() {}",
+    "*g() {};",
+    "; *g() {}",
+    "*g() {}; *h(x) {}",
     "static() {}",
     "static m() {}",
     "static get x() {}",
     "static set x(v) {}",
     "static get() {}",
     "static set() {}",
     "static static() {}",
     "static get static() {}",
     "static set static(v) {}",
+    "*static() {}",
+    "*get() {}",
+    "*set() {}",
+    "static *g() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(MethodDefinitionstrictFormalParamereters) {
-  const char* context_data[][2] = {{"({method(", "){}});"},
-                                   {NULL, NULL}};
-
-  const char* params_data[] = {
-    "x, x",
-    "x, y, x",
-    "eval",
-    "arguments",
-    "var",
-    "const",
-    NULL
-  };
-
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
-  RunParserSyncTest(context_data, params_data, kError, NULL, 0,
-                    always_flags, arraysize(always_flags));
-}
-
-
-TEST(NoErrorsClassPropertyName) {
+TEST(ClassPropertyNameNoErrors) {
   const char* context_data[][2] = {{"(class {", "() {}});"},
                                    {"(class { get ", "() {}});"},
                                    {"(class { set ", "(v) {}});"},
                                    {"(class { static ", "() {}});"},
                                    {"(class { static get ", "() {}});"},
                                    {"(class { static set ", "(v) {}});"},
+                                   {"(class { *", "() {}});"},
+                                   {"(class { static *", "() {}});"},
                                    {"class C {", "() {}}"},
                                    {"class C { get ", "() {}}"},
                                    {"class C { set ", "(v) {}}"},
                                    {"class C { static ", "() {}}"},
                                    {"class C { static get ", "() {}}"},
                                    {"class C { static set ", "(v) {}}"},
+                                   {"class C { *", "() {}}"},
+                                   {"class C { static *", "() {}}"},
                                    {NULL, NULL}};
   const char* name_data[] = {
     "42",
     "42.5",
     "42e2",
     "42e+2",
     "42e-2",
     "null",
     "false",
     "true",
@@ skipping 21 matching lines @@
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassExpression) {
+TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
     "class name extends",
     "class extends",
     "class {",
@@ skipping 10 matching lines @@
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassDeclaration) {
+TEST(ClassDeclarationErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"{", "}"},
                                    {"if (true) {", "}"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
     "class name extends",
     "class extends",
     "class name {",
     "class name { m }",
     "class name { m; n }",
     "class name { m: 1 }",
     "class name { m(); n() }",
-    "class name { get m }",
-    "class name { get m() }",
-    "class name { set m() {) }",  // missing required param
+    "class name { get x }",
+    "class name { get x() }",
+    "class name { set x() {) }",  // missing required param
     "class {}",  // Name is required for declaration
     "class extends base {}",
+    "class name { *",
+    "class name { * }",
+    "class name { *; }",
+    "class name { *get x() {} }",
+    "class name { *set x(_) {} }",
+    "class name { *static m() {} }",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyNumericLiterals
   };
   RunParserSyncTest(context_data, class_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassName) {
+TEST(ClassNameErrors) {
   const char* context_data[][2] = {{"class ", "{}"},
                                    {"(class ", "{});"},
                                    {"'use strict'; class ", "{}"},
                                    {"'use strict'; (class ", "{});"},
                                    {NULL, NULL}};
   const char* class_name[] = {
     "arguments",
     "eval",
     "implements",
     "interface",
     "let",
     "package",
     "private",
     "protected",
     "public",
     "static",
     "var",
     "yield",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassGetterParamName) {
+TEST(ClassGetterParamNameErrors) {
   const char* context_data[][2] = {
     {"class C { get name(", ") {} }"},
     {"(class { get name(", ") {} });"},
     {"'use strict'; class C { get name(", ") {} }"},
     {"'use strict'; (class { get name(", ") {} })"},
     {NULL, NULL}
   };
 
   const char* class_name[] = {
     "arguments",
@@ skipping 12 matching lines @@
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_name, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassStaticPrototype) {
+TEST(ClassStaticPrototypeErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "static prototype() {}",
     "static get prototype() {}",
     "static set prototype(_) {}",
+    "static *prototype() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassSpecialConstructor) {
+TEST(ClassSpecialConstructorErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "get constructor() {}",
     "get constructor(_) {}",
+    "*constructor() {}",

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

Andy, non static generator constructor is tested here.

     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(NoErrorsClassConstructor) {
+TEST(ClassConstructorNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}",
     "static constructor() {}",
     "static get constructor() {}",
     "static set constructor(_) {}",
+    "static *constructor() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassMultipleConstructor) {
+TEST(ClassMultipleConstructorErrors) {
   // We currently do not allow any duplicate properties in class bodies. This
   // test ensures that when we change that we still throw on duplicate
   // constructors.
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; constructor() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
 // TODO(arv): We should allow duplicate property names.
 // https://code.google.com/p/v8/issues/detail?id=3570
-DISABLED_TEST(NoErrorsClassMultiplePropertyNames) {
+DISABLED_TEST(ClassMultiplePropertyNamesNoErrors) {
   const char* context_data[][2] = {{"class C {", "}"},
                                    {"(class {", "});"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "constructor() {}; static constructor() {}",
     "m() {}; static m() {}",
     "m() {}; m() {}",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
-TEST(ErrorsClassesAreStrict) {
+TEST(ClassesAreStrictErrors) {
   const char* context_data[][2] = {{"", ""},
                                    {"(", ");"},
                                    {NULL, NULL}};
 
   const char* class_body_data[] = {
     "class C { method() { with ({}) {} } }",
     "class C extends function() { with ({}) {} } {}",
+    "class C { *method() { with ({}) {} } }",
     NULL};
 
   static const ParserFlag always_flags[] = {
     kAllowClasses,
     kAllowHarmonyObjectLiterals
   };
   RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
 }