Allow eval/arguments in arrow functions

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 3484 matching lines @@
 
     // Parameter lists with extra parens should be recognized as errors.
     "(()) => 0",
     "((x)) => 0",
     "((x, y)) => 0",
     "(x, (y)) => 0",
     "((x, y, z)) => 0",
     "(x, (y, z)) => 0",
     "((x, y), z) => 0",
 
-    // Parameter lists are always validated as strict, so those are errors.
-    "eval => {}",
-    "arguments => {}",
-    "yield => {}",
-    "interface => {}",
-    "(eval) => {}",
-    "(arguments) => {}",
-    "(yield) => {}",
-    "(interface) => {}",
-    "(eval, bar) => {}",
-    "(bar, eval) => {}",
-    "(bar, arguments) => {}",
-    "(bar, yield) => {}",
-    "(bar, interface) => {}",
+    // Arrow function formal parameters are parsed as StrictFormalParameters,
+    // which confusingly only implies that there are no duplicates.  Words
+    // reserved in strict mode, and eval or arguments, are indeed valid in
+    // sloppy mode.
+    "eval => { \"use strict\"; 0 }",

[arv (Not doing code reviews), 2015/04/13 18:26:38]

\" -> ' for readability

+    "arguments => { \"use strict\"; 0 }",
+    "yield => { \"use strict\"; 0 }",
+    "interface => { \"use strict\"; 0 }",
+    "(eval) => { \"use strict\"; 0 }",
+    "(arguments) => { \"use strict\"; 0 }",
+    "(yield) => { \"use strict\"; 0 }",
+    "(interface) => { \"use strict\"; 0 }",
+    "(eval, bar) => { \"use strict\"; 0 }",
+    "(bar, eval) => { \"use strict\"; 0 }",
+    "(bar, arguments) => { \"use strict\"; 0 }",
+    "(bar, yield) => { \"use strict\"; 0 }",
+    "(bar, interface) => { \"use strict\"; 0 }",
     // TODO(aperez): Detecting duplicates does not work in PreParser.
     // "(bar, bar) => {}",
 
     // The parameter list is parsed as an expression, but only
     // a comma-separated list of identifier is valid.
     "32 => {}",
     "(32) => {}",
     "(a, 32) => {}",
     "if => {}",
     "(if) => {}",
@@ skipping 86 matching lines @@
     "foo ? bar : baz => {}",
     NULL
   };
 
   static const ParserFlag always_flags[] = {kAllowHarmonyArrowFunctions};
   RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
                     always_flags, arraysize(always_flags));
 }
 
 
+TEST(ArrowFunctionsSloppyParameterNames) {
+  const char* strong_context_data[][2] = {
+    {"\"use strong\"; ", ";"},
+    {"\"use strong\"; bar ? (", ") : baz;"},
+    {"\"use strong\"; bar ? baz : (", ");"},
+    {"\"use strong\"; bar, ", ";"},
+    {"\"use strong\"; ", ", bar;"},
+    {NULL, NULL}
+  };
+
+  const char* strict_context_data[][2] = {
+    {"\"use strict\"; ", ";"},
+    {"\"use strict\"; bar ? (", ") : baz;"},
+    {"\"use strict\"; bar ? baz : (", ");"},
+    {"\"use strict\"; bar, ", ";"},
+    {"\"use strict\"; ", ", bar;"},
+    {NULL, NULL}
+  };
+
+  const char* sloppy_context_data[][2] = {
+    {"", ";"},
+    {"bar ? (", ") : baz;"},
+    {"bar ? baz : (", ");"},
+    {"bar, ", ";"},
+    {"", ", bar;"},
+    {NULL, NULL}
+  };
+
+  const char* statement_data[] = {
+    "eval => {}",
+    "arguments => {}",
+    "yield => {}",
+    "interface => {}",
+    "(eval) => {}",
+    "(arguments) => {}",
+    "(yield) => {}",
+    "(interface) => {}",
+    "(eval, bar) => {}",
+    "(bar, eval) => {}",
+    "(bar, arguments) => {}",
+    "(bar, yield) => {}",
+    "(bar, interface) => {}",
+    NULL
+  };
+
+  static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions,
+                                             kAllowStrongMode};
+  RunParserSyncTest(strong_context_data, statement_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(strict_context_data, statement_data, kError, NULL, 0,
+                    always_flags, arraysize(always_flags));
+  RunParserSyncTest(sloppy_context_data, statement_data, kSuccess, NULL, 0,
+                    always_flags, arraysize(always_flags));
+}
+
+
 TEST(SuperNoErrors) {
   // Tests that parser and preparser accept 'super' keyword in right places.
   const char* context_data[][2] = {
     {"class C { m() { ", "; } }"},
     {"class C { m() { k = ", "; } }"},
     {"class C { m() { foo(", "); } }"},
     {"class C { m() { () => ", "; } }"},
     {NULL, NULL}
   };
 
@@ skipping 2435 matching lines @@
     v8::Script::Compile(v8_str(script3));
     CHECK(try_catch2.HasCaught());
     v8::String::Utf8Value exception(try_catch2.Exception());
     CHECK_EQ(0,
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }