[runtime] Support Proxy setPrototypeOf trap

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 2264 matching lines @@
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowStrongMode};
   RunParserSyncTest(context_data, statement_data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(ErrorsYieldSloppy) {
-  const char* context_data[][2] = {
-    { "", "" },
-    { "function not_gen() {", "}" },
-    { "(function not_gen() {", "})" },
-    { NULL, NULL }
-  };
+  const char* context_data[][2] = {{"", ""},
+                                   {"function not_gen() {", "}"},
+                                   {"(function not_gen() {", "})"},
+                                   {NULL, NULL}};
 
-  const char* statement_data[] = {
-    "(function * yield() { })",
-    NULL
-  };
+  const char* statement_data[] = {"(function * yield() { })", NULL};
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(NoErrorsGenerator) {
   const char* context_data[][2] = {
     { "function * gen() {", "}" },
     { "(function * gen() {", "})" },
     { "(function * () {", "})" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
-    // A generator without a body is valid.
-    ""
-    // Valid yield expressions inside generators.
-    "yield 2;",
-    "yield * 2;",
-    "yield * \n 2;",
-    "yield yield 1;",
-    "yield * yield * 1;",
-    "yield 3 + (yield 4);",
-    "yield * 3 + (yield * 4);",
-    "(yield * 3) + (yield * 4);",
-    "yield 3; yield 4;",
-    "yield * 3; yield * 4;",
-    "(function (yield) { })",
-    "(function yield() { })",
-    "yield { yield: 12 }",
-    "yield /* comment */ { yield: 12 }",
-    "yield * \n { yield: 12 }",
-    "yield /* comment */ * \n { yield: 12 }",
-    // You can return in a generator.
-    "yield 1; return",
-    "yield * 1; return",
-    "yield 1; return 37",
-    "yield * 1; return 37",
-    "yield 1; return 37; yield 'dead';",
-    "yield * 1; return 37; yield * 'dead';",
-    // Yield is still a valid key in object literals.
-    "({ yield: 1 })",
-    "({ get yield() { } })",
-    // Yield without RHS.
-    "yield;",
-    "yield",
-    "yield\n",
-    "yield /* comment */"
-    "yield // comment\n"
-    "(yield)",
-    "[yield]",
-    "{yield}",
-    "yield, yield",
-    "yield; yield",
-    "(yield) ? yield : yield",
-    "(yield) \n ? yield : yield",
-    // If there is a newline before the next token, we don't look for RHS.
-    "yield\nfor (;;) {}",
-    NULL
-  };
+      // A generator without a body is valid.
+      ""
+      // Valid yield expressions inside generators.
+      "yield 2;",
+      "yield * 2;", "yield * \n 2;", "yield yield 1;", "yield * yield * 1;",
+      "yield 3 + (yield 4);", "yield * 3 + (yield * 4);",
+      "(yield * 3) + (yield * 4);", "yield 3; yield 4;",
+      "yield * 3; yield * 4;", "(function (yield) { })",
+      "(function yield() { })", "yield { yield: 12 }",
+      "yield /* comment */ { yield: 12 }", "yield * \n { yield: 12 }",
+      "yield /* comment */ * \n { yield: 12 }",
+      // You can return in a generator.
+      "yield 1; return", "yield * 1; return", "yield 1; return 37",
+      "yield * 1; return 37", "yield 1; return 37; yield 'dead';",
+      "yield * 1; return 37; yield * 'dead';",
+      // Yield is still a valid key in object literals.
+      "({ yield: 1 })", "({ get yield() { } })",
+      // Yield without RHS.
+      "yield;", "yield", "yield\n",
+      "yield /* comment */"
+      "yield // comment\n"
+      "(yield)",
+      "[yield]", "{yield}", "yield, yield", "yield; yield",
+      "(yield) ? yield : yield", "(yield) \n ? yield : yield",
+      // If there is a newline before the next token, we don't look for RHS.
+      "yield\nfor (;;) {}", NULL};
 
   RunParserSyncTest(context_data, statement_data, kSuccess);
 }
 
 
 TEST(ErrorsYieldGenerator) {
   const char* context_data[][2] = {
     { "function * gen() {", "}" },
     { "\"use strict\"; function * gen() {", "}" },
     { NULL, NULL }
   };
 
   const char* statement_data[] = {
-    // Invalid yield expressions inside generators.
-    "var yield;",
-    "var foo, yield;",
-    "try { } catch (yield) { }",
-    "function yield() { }",
-    // The name of the NFE is bound in the generator, which does not permit
-    // yield to be an identifier.
-    "(function * yield() { })",
-    // Yield isn't valid as a formal parameter for generators.
-    "function * foo(yield) { }",
-    "(function * foo(yield) { })",
-    "yield = 1;",
-    "var foo = yield = 1;",
-    "++yield;",
-    "yield++;",
-    "yield *",
-    "(yield *)",
-    // Yield binds very loosely, so this parses as "yield (3 + yield 4)", which
-    // is invalid.
-    "yield 3 + yield 4;",
-    "yield: 34",
-    "yield ? 1 : 2",
-    // Parses as yield (/ yield): invalid.
-    "yield / yield",
-    "+ yield",
-    "+ yield 3",
-    // Invalid (no newline allowed between yield and *).
-    "yield\n*3",
-    // Invalid (we see a newline, so we parse {yield:42} as a statement, not an
-    // object literal, and yield is not a valid label).
-    "yield\n{yield: 42}",
-    "yield /* comment */\n {yield: 42}",
-    "yield //comment\n {yield: 42}",
-    NULL
-  };
+      // Invalid yield expressions inside generators.
+      "var yield;", "var foo, yield;", "try { } catch (yield) { }",
+      "function yield() { }",
+      // The name of the NFE is bound in the generator, which does not permit
+      // yield to be an identifier.
+      "(function * yield() { })",
+      // Yield isn't valid as a formal parameter for generators.
+      "function * foo(yield) { }", "(function * foo(yield) { })", "yield = 1;",
+      "var foo = yield = 1;", "++yield;", "yield++;", "yield *", "(yield *)",
+      // Yield binds very loosely, so this parses as "yield (3 + yield 4)",
+      // which
+      // is invalid.
+      "yield 3 + yield 4;", "yield: 34", "yield ? 1 : 2",
+      // Parses as yield (/ yield): invalid.
+      "yield / yield", "+ yield", "+ yield 3",
+      // Invalid (no newline allowed between yield and *).
+      "yield\n*3",
+      // Invalid (we see a newline, so we parse {yield:42} as a statement, not
+      // an
+      // object literal, and yield is not a valid label).
+      "yield\n{yield: 42}", "yield /* comment */\n {yield: 42}",
+      "yield //comment\n {yield: 42}", NULL};
 
   RunParserSyncTest(context_data, statement_data, kError);
 }
 
 
 TEST(ErrorsNameOfStrictFunction) {
   // Tests that illegal tokens as names of a strict function produce the correct
   // errors.
   const char* context_data[][2] = {
     { "function ", ""},
@@ skipping 5065 matching lines @@
                               "var publ\\u0069c = 1;",
                               "var { publ\\u0069c } = {};",
                               NULL};
   RunParserSyncTest(sloppy_context_data, valid_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
                     always_flags, arraysize(always_flags));
   RunModuleParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
                           always_flags, arraysize(always_flags));
 }