[destructuring] Parse binding patterns in formal parameters.

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 6362 matching lines @@
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }
 
 
 TEST(DestructuringPositiveTests) {
   i::FLAG_harmony_destructuring = true;
+  i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
 
   const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                    {"var ", " = {};"},
                                    {"'use strict'; const ", " = {};"},
+                                   {"function f(", ") {}"},
+                                   {"function f(argument1, ", ") {}"},
+                                   {"var f = (", ") => {};"},
+                                   {"var f = ", " => {};"},
+                                   {"var f = (argument1,", ") => {};"},
                                    {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "a",
     "{ x : y }",
     "{ x : y = 1 }",
     "[a]",
     "[a = 1]",
     "[a,b,c]",
@@ skipping 19 matching lines @@
     "{var: x = 42}",
     "{[x] : z}",
     "{[1+1] : z}",
     "{[foo()] : z}",
     "{}",
     "[...rest]",
     "[a,b,...rest]",
     "[a,,...rest]",
     NULL};
   // clang-format on
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals,
-                                            kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
+      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(DestructuringNegativeTests) {
   i::FLAG_harmony_destructuring = true;
+  i::FLAG_harmony_arrow_functions = true;
   i::FLAG_harmony_computed_property_names = true;
-  static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals,
-                                            kAllowHarmonyComputedPropertyNames,
-                                            kAllowHarmonyDestructuring};
+  static const ParserFlag always_flags[] = {
+      kAllowHarmonyObjectLiterals, kAllowHarmonyComputedPropertyNames,
+      kAllowHarmonyArrowFunctions, kAllowHarmonyDestructuring};
 
   {  // All modes.
     const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
                                      {"var ", " = {};"},
                                      {"'use strict'; const ", " = {};"},
+                                     {"function f(", ") {}"},
+                                     {"function f(argument1, ", ") {}"},
+                                     {"var f = (", ") => {};"},
+                                     {"var f = ", " => {};"},
+                                     {"var f = (argument1,", ") => {};"},
                                      {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
         "a++",
         "++a",
         "delete a",
         "void a",
         "typeof a",
         "--a",
@@ skipping 12 matching lines @@
         "a * a",
         "a / a",
         "a == a",
         "a != a",
         "a > a",
         "a < a",
         "a <<< a",
         "a >>> a",
         "function a() {}",
         "a`bcd`",
-        "x => x",
         "this",
         "null",
         "true",
         "false",
         "1",
         "'abc'",
         "class {}",
-        "() => x",
         "{+2 : x}",
         "{-2 : x}",
         "var",
         "[var]",
         "{x : {y : var}}",
         "{x : x = a+}",
         "{x : x = (a+)}",
         "{x : x += a}",
         "{m() {} = 0}",
         "{[1+1]}",
         "[...rest, x]",
         "[a,b,...rest, x]",
         "[a,,...rest, x]",
         "[...rest,]",
         "[a,b,...rest,]",
         "[a,,...rest,]",
         "[...rest,...rest1]",
         "[a,b,...rest,...rest1]",
         "[a,,..rest,...rest1]",
         NULL};
     // clang-format on
     RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                       arraysize(always_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,", ") => {};"},
+                                     {NULL, NULL}};
+
+    // clang-format off
+    const char* data[] = {
+        "x => x",
+        "() => x",
+        NULL};
+    // clang-format on
+    RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
+                      arraysize(always_flags));
+  }
+
   {  // Strict mode.
-    const char* context_data[][2] = {{"'use strict'; let ", " = {};"},
-                                     {"'use strict'; const ", " = {};"},
-                                     {NULL, NULL}};
+    const char* context_data[][2] = {
+        {"'use strict'; let ", " = {};"},
+        {"'use strict'; const ", " = {};"},
+        {"'use strict'; function f(", ") {}"},
+        {"'use strict'; function f(argument1, ", ") {}"},
+        {NULL, NULL}};
 
     // clang-format off
     const char* data[] = {
       "[eval]",
       "{ a : arguments }",
       "[public]",
       "{ x : private }",
       NULL};
     // clang-format on
     RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
@@ skipping 39 matching lines @@
   // clang-format off
   const char* success_data[] = {
     "for (var x = {} in null);",
     NULL};
   // clang-format on
   RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
+TEST(DestructuringParameterPatternsPositive) {
+  i::FLAG_harmony_destructuring = true;
+  static const ParserFlag always_flags[] = {kAllowHarmonyDestructuring};
+
+  const char* context_data[][2] = {
+      {"function f(", "){}"}, {"function f(x, ", "){}"}, {NULL, NULL}};
+
+  // clang-format off
+  const char* success_data[] = {
+    "{a : a}",

[arv (Not doing code reviews), 2015/06/15 15:21:59]

Isn't this case already covered on line 6405?

[Dmitry Lomov (no reviews), 2015/06/15 16:12:51]

Removed.

+    NULL};
+  // clang-format on
+  RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0, always_flags,
+                    arraysize(always_flags));
+}
+
+
 TEST(SpreadArray) {
   i::FLAG_harmony_spread_arrays = true;
 
   const char* context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "[...a]",
     "[a, ...b]",
@@ skipping 80 matching lines @@
     kAllowHarmonyObjectLiterals,
     kAllowHarmonySloppy,
   };
   // clang-format on
 
   RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
   RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }