[parser] Throw error when there are too many excluded properties

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 6953 matching lines @@
       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));
   }
+
+  {
+    // clang-format off
+    const char* context_data[][2] = {
+      {"var { ", " } = { a: 1};"},
+      { NULL, NULL }
+    };
+
+    using v8::internal::Code;
+    std::string statement;
+    for (int i = 0; i < Code::kMaxArguments; ++i) {
+      statement += std::to_string(i) + " : " + "x, ";
+    }
+    statement += "...y";
+
+    const char* statement_data[] = {
+      statement.c_str(),
+      NULL
+    };
+
+    // clang-format on
+    // The test is quite slow, so run it with a reduced set of flags.

[adamk, 2017/01/23 21:47:45]

How slow did this end up being?

Depending on your answer to that, it would be nice to show that Object spread
allows more than kMaxArguments.

[gsathya, 2017/01/23 22:22:27]

This doubled the run time of the test (13s to 25s). 
We don't pass all the properties in this case, so not sure what this will be
testing?

+    static const ParserFlag flags[] = {kAllowLazy,
+                                       kAllowHarmonyObjectRestSpread};
+    RunParserSyncTest(context_data, statement_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 ", " = {});"},
       {"var x, y, z; for (x in ", " = {});"},
@@ skipping 1942 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));
     }
   }
 }