[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 1266 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 5275 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,", ") => {};"},
@@ skipping 35 matching lines @@
     "{[1+1] : z}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
     "{ __proto__: x, __proto__: y}",
     "{arguments: x}",
     "{eval: x}",
     NULL};
+
+  const char* rest_data[] =  {
+    "{ x : y, ...z }",
+    "{ x : y = 1, ...z }",
+    "{ x : x, y : y, ...z }",
+    "{ x : x = 1, y : y, ...z }",
+    "{ x : x, y : y = 42, ...z }",
+    "[{x:x, y:y, ...z}, [a,b,c]]",
+    "[{x:x = 1, y:y = 2, ...z}, [a = 3, b = 4, c = 5]]",
+    "{...x}",
+    "{...{ x = 5} }",
+    "{x, ...y}",
+    "{x = 42, y = 15, ...z}",
+    "{42 : x = 42, ...y}",
+    "{'hi' : x, ...z}",
+    "{'hi' : x = 42, ...z}",
+    "{var: x = 42, ...z}",
+    "{[x] : z, ...y}",
+    "{[1+1] : z, ...x}",
+    "{arguments: x, ...z}",
+    "{ __proto__: x, __proto__: y, ...z}",
+    NULL};
+
   // clang-format on
   RunParserSyncTest(context_data, data, kSuccess);
+  RunParserSyncTest(context_data, rest_data, kError);
+
+  static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                    arraysize(flags));
+  RunParserSyncTest(context_data, rest_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* rest_data[] = {
+      "{...arguments}",
+      "{...eval}",
+      NULL
+    };
+
     const char* data[] = {
       "{arguments}",
       "{eval}",
       "{x: arguments}",
       "{x: eval}",
       "{arguments = false}",
       "{eval = false}",
       NULL
     };
     // clang-format on
     RunParserSyncTest(sloppy_context_data, data, kSuccess);
+    RunParserSyncTest(sloppy_context_data, rest_data, kError);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(sloppy_context_data, data, kSuccess, NULL, 0, flags,
+                      arraysize(flags));
+    RunParserSyncTest(sloppy_context_data, rest_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(", ") {}"},
@@ skipping 68 matching lines @@
         "[...[z] = [1]]",
         "{ x : 3 }",
         "{ x : 'foo' }",
         "{ x : /foo/ }",
         "{ x : `foo` }",
         "{ get a() {} }",
         "{ set a() {} }",
         "{ method() {} }",
         "{ *method() {} }",
         NULL};
+
+    const char* rest_data[] = {
+      "...a++",
+      "...++a",
+      "...typeof a",
+      "...[a++]",
+      "...(x => y)",
+      "{ ...x, }",
+      "{ ...x, y }",
+      "{ y, ...x, y }",
+      "{ ...x, ...y }",
+      "{ ...x, ...x }",
+      "{ ...x, ...x = {} }",
+      "{ ...x, ...x = ...x }",
+      "{ ...x, ...x = ...{ x } }",
+      "{ ,, ...x }",
+      "{ ...get a() {} }",
+      "{ ...set a() {} }",
+      "{ ...method() {} }",
+      "{ ...function() {} }",
+      "{ ...*method() {} }",
+      NULL
+    };
+
     // clang-format on
     RunParserSyncTest(context_data, data, kError);
+    RunParserSyncTest(context_data, rest_data, kError);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
+    RunParserSyncTest(context_data, rest_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 25 matching lines @@
       "{ a : eval }",
       "[public]",
       "{ x : private }",
       "{ x : arguments }",
       "{ x : eval }",
       "{ arguments }",
       "{ eval }",
       "{ arguments = false }"
       "{ eval = false }",
       NULL};
+
+    const char* rest_data[] = {
+      "{ ...eval }",
+      "{ ...arguments }",
+      NULL};
+
     // clang-format on
     RunParserSyncTest(context_data, data, kError);
+    RunParserSyncTest(context_data, rest_data, kError);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
+    RunParserSyncTest(context_data, rest_data, kError, NULL, 0, flags,
+                      arraysize(flags));
   }
 
   {  // 'yield' in generators.
     const char* context_data[][2] = {
         {"function*() { var ", " = {};"},
         {"function*() { 'use strict'; let ", " = {};"},
         {"function*() { 'use strict'; const ", " = {};"},
         {NULL, NULL}};
 
     // clang-format off
@@ skipping 19 matching lines @@
                                      {"for (var ", ";;) {}"},
                                      {"for (let ", ";;) {}"},
                                      {"for (const ", ";;) {}"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "{ a }",
       "[ a ]",
       NULL};
+    const char* rest_data[] = {
+      "{ ...a }",
+      NULL};
     // clang-format on
     RunParserSyncTest(context_data, data, kError);
+    RunParserSyncTest(context_data, rest_data, kError);
+    static const ParserFlag flags[] = {kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(context_data, data, kError, NULL, 0, flags,
+                      arraysize(flags));
+    RunParserSyncTest(context_data, rest_data, kError, NULL, 0, flags,
+                      arraysize(flags));
   }
 }
 
 
 TEST(DestructuringAssignmentPositiveTests) {
   const char* context_data[][2] = {
       {"'use strict'; let x, y, z; (", " = {});"},
       {"var x, y, z; (", " = {});"},
       {"'use strict'; let x, y, z; for (x in ", " = {});"},
       {"'use strict'; let x, y, z; for (x of ", " = {});"},
@@ skipping 1944 matching lines @@
       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));
     }
   }
 }