[ESnext] Implement Object spread

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 1250 matching lines @@
 const char* ReadString(unsigned* start) {
   int length = start[0];
   char* result = i::NewArray<char>(length + 1);
   for (int i = 0; i < length; i++) {
     result[i] = start[i + 1];
   }
   result[length] = '\0';
   return result;
 }
 
-
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyAsyncAwait,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
+  kAllowHarmonyObjectSpread,
 };
 
 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_async_await = flags.Contains(kAllowHarmonyAsyncAwait);
   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);
 }
 
 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_async_await(
       flags.Contains(kAllowHarmonyAsyncAwait));
   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));
 }
 
 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 5237 matching lines @@
       "(a\n=> a)(1)",
       "(a/*\n*/=> a)(1)",
       "((a)\n=> a)(1)",
       "((a)/*\n*/=> a)(1)",
       "((a, b)\n=> a + b)(1, 2)",
       "((a, b)/*\n*/=> a + b)(1, 2)",
       NULL};
   RunParserSyncTest(context_data, data, kError);
 }
 
+TEST(ObjectSpreadPositiveTests) {
+  const char* context_data[][2] = {
+      {"'use strict'; let y = { a: 1}; let x = ", ""},

[adamk, 2016/12/29 00:48:45]

Generally the context data is about different sorts of things than this, i.e.,
function vs top-level, strict vs non-strict.

For this I'd just start with something like the context data for the previous
test: strict vs non-strict, and then an expression context. Since these are just
parsing tests, there's no need to set up the "environment" like you've done here
(i.e., don't need to define variables you "reference").

[gsathya, 2016/12/29 06:40:56]

Done.

[adamk, 2016/12/29 18:32:45]

Sorry if I wasn't clear, but I don't think you need this much context. Just the
following would give you the same amount of coverage:

{"x = ", ""},
{"'use strict'; x = ", ""}

[gsathya, 2017/01/05 22:18:35]

Done.

+      {"var y = { a: 1}, x = ", ""},
+      {"var y = { a: 1}; var x = ", ""},
+      {"'use strict'; const y = { a: 1}; const x = ", ""},
+      {"function f(y = { a: 1}, x = ", ") {}"},
+      {"var y = { a: 1 }; function f(x = ", ") {}"},
+      {"var y = { a: 1 }; var f = (x = ", ") => {};"},
+      {"var f = (y = { a: 1 }, x = ", ") => {};"},
+      {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}",
+    NULL};
+
+  static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
+  RunParserSyncTest(context_data, data, kSuccess, NULL, 0, flags,
+                    arraysize(flags));
+}
+
+TEST(ObjectSpreadNegativeTests) {
+  {
+    const char* context_data[][2] = {
+      {"'use strict'; let y = { a: 1}; let x = ", ""},

[adamk, 2016/12/29 00:48:45]

Same comment on context data here.

[gsathya, 2016/12/29 06:40:56]

Done.

[adamk, 2016/12/29 18:32:45]

Same here

[gsathya, 2017/01/05 22:18:35]

Done.

+      {"var y = { a: 1}, x = ", ""},
+      {"var y = { a: 1}; var x = ", ""},
+      {"'use strict'; const y = { a: 1}; const x = ", ""},
+      {"function f(y = { a: 1}, x = ", ") {}"},
+      {"var y = { a: 1 }; function f(x = ", ") {}"},
+      {"var y = { a: 1 }; var f = (x = ", ") => {};"},
+      {"var f = (y = { a: 1 }, x = ", ") => {};"},
+      {NULL, NULL}};
+
+    // clang-format off
+    const char* data[] = {
+      "{ ...var z = y}",

[adamk, 2016/12/29 00:48:45]

I agree that negative tests are kinda tricky for this. Keywords is all that
really comes to mind at the moment (other than destructuring, which you handle
below).

[gsathya, 2016/12/29 06:40:56]

Done.

[adamk, 2016/12/29 18:32:45]

? I don't see any additional tests here.

+      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(", ") {}"},

[adamk, 2016/12/29 00:48:45]

Need to add an assignment context.

+      {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}",
+      NULL};
+
+    static const ParserFlag flags[] = {kAllowHarmonyObjectSpread};
+    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(", ") {}"},
@@ skipping 2118 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));
   }
 }