[ESnext] Implement Object Rest

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 1259 matching lines @@
   return result;
 }
 
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
-  kAllowHarmonyObjectSpread,
+  kAllowHarmonyObjectRestSpread,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 void SetGlobalFlags(i::EnumSet<ParserFlag> flags) {
   i::FLAG_allow_natives_syntax = flags.Contains(kAllowNatives);
   i::FLAG_harmony_function_sent = flags.Contains(kAllowHarmonyFunctionSent);
   i::FLAG_harmony_restrictive_generators =
       flags.Contains(kAllowHarmonyRestrictiveGenerators);
   i::FLAG_harmony_trailing_commas = flags.Contains(kAllowHarmonyTrailingCommas);
   i::FLAG_harmony_class_fields = flags.Contains(kAllowHarmonyClassFields);
-  i::FLAG_harmony_object_spread = flags.Contains(kAllowHarmonyObjectSpread);
+  i::FLAG_harmony_object_rest_spread =
+      flags.Contains(kAllowHarmonyObjectRestSpread);
 }
 
 void SetParserFlags(i::PreParser* parser, i::EnumSet<ParserFlag> flags) {
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
   parser->set_allow_harmony_trailing_commas(
       flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
-  parser->set_allow_harmony_object_spread(
-      flags.Contains(kAllowHarmonyObjectSpread));
+  parser->set_allow_harmony_object_rest_spread(
+      flags.Contains(kAllowHarmonyObjectRestSpread));
 }
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result,
                              bool is_module = false,
                              bool test_preparser = true) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
@@ skipping 5211 matching lines @@
     "{ ...1}",
     "{ ...null}",
     "{ ...undefined}",
     "{ ...1 in {}}",
     "{ ...[]}",
     "{ ...async function() { }}",
     "{ ...async () => { }}",
     "{ ...new Foo()}",
     NULL};
 
-  static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
+  static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
                     arraysize(flags));
 }
 
 TEST(ObjectSpreadNegativeTests) {
-  {
-    const char* context_data[][2] = {{"x = ", ""},
-                                     {"'use strict'; x = ", ""},
-                                     {NULL, NULL}};
+  const char* context_data[][2] = {{"x = ", ""},
+                                   {"'use strict'; x = ", ""},
+                                   {NULL, NULL}};
 
-    // clang-format off
-    const char* data[] = {
-      "{ ...var z = y}",
-      "{ ...var}",
-      "{ ...foo bar}",
-      NULL};
+  // clang-format off
+  const char* data[] = {
+    "{ ...var z = y}",
+    "{ ...var}",
+    "{ ...foo bar}",
+    NULL};
 
-    static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
-    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
-                      arraysize(flags));
-  }
-
-  // Destructuring tests
-  {
-    const char* context_data[][2] = {
-      {"var ", " = {};"},
-      {"( ", " = {});"},
-      {"'use strict'; const ", " = {};"},
-      {"function f(", ") {}"},
-      {"function f(argument1, ", ") {}"},
-      {"var f = (", ") => {};"},
-      {"var f = (argument1,", ") => {};"},
-      {"try {} catch(", ") {}"},
-      {NULL, NULL}};
-
-    // clang-format off
-    const char* data[] = {
-      "{ ...y }",
-      "{ a: 1, ...y }",
-      "{ b: 1, ...y }",
-      "{ y, ...y}",
-      "{ ...z = y}",
-      "{ ...y, y }",
-      "{ ...y, ...y}",
-      "{ a: 1, ...y, b: 1}",
-      "{ ...y, b: 1}",
-      "{ ...1}",
-      "{ ...null}",
-      "{ ...undefined}",
-      "{ ...unknown}",
-      "{ ...var z = y}",
-      "({ ...z = {})",
-      NULL};
-
-    static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
-    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
-                      arraysize(flags));
-  }
+  static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+  RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                    arraysize(flags));
 }
 
 TEST(DestructuringPositiveTests) {
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
                                    {"function f(", ") {}"},
                                    {"function f(argument1, ", ") {}"},
                                    {"var f = (", ") => {};"},
                                    {"var f = (argument1,", ") => {};"},
                                    {"try {} catch(", ") {}"},
                                    {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "a",
     "{ x : y }",
+    "{ x : y, ...z }",

[adamk, 2017/01/12 22:43:08]

Rather than interleaving the new tests and always turning the RestSpread flag
on, you should create a separate array of data holding just those patterns
including rest syntax. Then you can have four calls to RunTests:

RunTests(data, noflags, kSuccess)
RunTests(rest_data, noflags, kFailure)
RunTests(data, RestSpreadFlag, kSuccess)
RunTests(rest_data, RestSpreadFlag, kSuccess)

Once the feature is shipped, you can then merge data and rest_data and have a
single call.

Side note: this would be a good thing for us to fix with more test
infrastructure.

[gsathya, 2017/01/17 19:28:59]

Done.

     "{ x : y = 1 }",
+    "{ x : y = 1, ...z }",
     "{ get, set }",
     "{ get = 1, set = 2 }",
     "[a]",
     "[a = 1]",
     "[a,b,c]",
     "[a, b = 42, c]",
     "{ x : x, y : y }",
+    "{ x : x, y : y, ...z }",
     "{ x : x = 1, y : y }",
+    "{ x : x = 1, y : y, ...z }",
     "{ x : x, y : y = 42 }",
+    "{ x : x, y : y = 42, ...z }",
     "[]",
     "{}",
     "[{x:x, y:y}, [a,b,c]]",
+    "[{x:x, y:y, ...z}, [a,b,c]]",
     "[{x:x = 1, y:y = 2}, [a = 3, b = 4, c = 5]]",
-    "{x}",
+    "[{x:x = 1, y:y = 2, ...z}, [a = 3, b = 4, c = 5]]",
+    "{...x}",
+    "{...{ x = 5} }",
     "{x, y}",
+    "{x, ...y}",
     "{x = 42, y = 15}",
+    "{x = 42, y = 15, ...z}",
     "[a,,b]",
     "{42 : x}",
     "{42 : x = 42}",
+    "{42 : x = 42, ...y}",
     "{42e-2 : x}",
     "{42e-2 : x = 42}",
     "{x : y, x : z}",
     "{'hi' : x}",
+    "{'hi' : x, ...z}",
     "{'hi' : x = 42}",
+    "{'hi' : x = 42, ...z}",
     "{var: x}",
     "{var: x = 42}",
+    "{var: x = 42, ...z}",
     "{[x] : z}",
+    "{[x] : z, ...y}",
     "{[1+1] : z}",
+    "{[1+1] : z, ...x}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
     "{ __proto__: x, __proto__: y}",
+    "{ __proto__: x, __proto__: y, ...z}",
     "{arguments: x}",
+    "{arguments: x, ...z}",
     "{eval: x}",
     NULL};
   // clang-format on
-  RunParserSyncTest(context_data, data, kSuccess);
+  static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                    arraysize(flags));
 
   // v8:5201
   {
     // clang-format off
     const char* sloppy_context_data[][2] = {
       {"var ", " = {};"},
       {"function f(", ") {}"},
       {"function f(argument1, ", ") {}"},
       {"var f = (", ") => {};"},
       {"var f = (argument1,", ") => {};"},
       {"try {} catch(", ") {}"},
       {NULL, NULL}
     };
     const char* data[] = {
       "{arguments}",
       "{eval}",
       "{x: arguments}",
       "{x: eval}",
       "{arguments = false}",
       "{eval = false}",
+      "{...arguments}",
+      "{...eval}",
+      "{z, ...z,}",
       NULL
     };
     // clang-format on
-    RunParserSyncTest(sloppy_context_data, data, kSuccess);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(sloppy_context_data, data, kSuccess, NULL, 0, flags,
+                      arraysize(flags));
   }
 }
 
 
 TEST(DestructuringNegativeTests) {
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
                                      {"function f(", ") {}"},
                                      {"function f(argument1, ", ") {}"},
                                      {"var f = (", ") => {};"},
                                      {"var f = ", " => {};"},
                                      {"var f = (argument1,", ") => {};"},
                                      {"try {} catch(", ") {}"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
         "a++",
+        "...a++",
         "++a",
+        "...++a",
         "delete a",
         "void a",
         "typeof a",
+        "...typeof a",
         "--a",
         "+a",
         "-a",
         "~a",
         "!a",
         "{ x : y++ }",
         "[a++]",
+        "...[a++]",
         "(x => y)",
+        "...(x => y)",
         "a[i]", "a()",
         "a.b",
         "new a",
         "a + a",
         "a - a",
         "a * a",
         "a / a",
         "a == a",
         "a != a",
         "a > a",
@@ skipping 27 matching lines @@
         "[...rest,]",
         "[a,b,...rest,]",
         "[a,,...rest,]",
         "[...rest,...rest1]",
         "[a,b,...rest,...rest1]",
         "[a,,..rest,...rest1]",
         "[x, y, ...z = 1]",
         "[...z = 1]",
         "[x, y, ...[z] = [1]]",
         "[...[z] = [1]]",
+        "{ ...x, }",
+        "{ ...x, y }",
+        "{ y, ...x, y }",
+        "{ ...x, ...y }",
+        "{ ...x, ...x }",
+        "{ ...x, ...x = {} }",
+        "{ ...x, ...x = ...x }",
+        "{ ...x, ...x = ...{ x } }",
+        "{ ,, ...x }",
         "{ x : 3 }",
         "{ x : 'foo' }",
         "{ x : /foo/ }",
         "{ x : `foo` }",
         "{ get a() {} }",
+        "{ ...get a() {} }",
         "{ set a() {} }",
+        "{ ...set a() {} }",
         "{ method() {} }",
+        "{ ...method() {} }",
+        "{ ...function() {} }",
         "{ *method() {} }",
+        "{ ...*method() {} }",
         NULL};
     // clang-format on
-    RunParserSyncTest(context_data, data, kError);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
   }
 
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
                                      {"function f(", ") {}"},
                                      {"function f(argument1, ", ") {}"},
                                      {"var f = (", ") => {};"},
                                      {"var f = (argument1,", ") => {};"},
@@ skipping 2053 matching lines @@
     DCHECK_NOT_NULL(scope);
     DCHECK_NULL(scope->sibling());
     DCHECK(scope->is_function_scope());
     const i::AstRawString* var_name =
         info.ast_value_factory()->GetOneByteString("my_var");
     i::Variable* var = scope->Lookup(var_name);
     CHECK_EQ(inners[i].ctxt_allocate,
              i::ScopeTestHelper::MustAllocateInContext(var));
   }
 }