[es6] support AssignmentPattern as LHS in for-in/of loops

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 6810 matching lines @@
 
 
 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 ", " = {});"},
       {"var x, y, z; for (x of ", " = {});"},
+      {"var x, y, z; for (", " in {});"},
+      {"var x, y, z; for (", " of {});"},
+      {"'use strict'; var x, y, z; for (", " in {});"},
+      {"'use strict'; var x, y, z; for (", " of {});"},
+      {NULL, NULL}};
+
+  const char* mixed_assignments_context_data[][2] = {
+      {"'use strict'; let x, y, z; (", " = z = {});"},
+      {"var x, y, z; (", " = z = {});"},
+      {"'use strict'; let x, y, z; (x = ", " = z = {});"},
+      {"var x, y, z; (x = ", " = z = {});"},
+      {"'use strict'; let x, y, z; for (x in ", " = z = {});"},
+      {"'use strict'; let x, y, z; for (x in x = ", " = z = {});"},
+      {"'use strict'; let x, y, z; for (x of ", " = z = {});"},
+      {"'use strict'; let x, y, z; for (x of x = ", " = z = {});"},
+      {"var x, y, z; for (x in ", " = z = {});"},
+      {"var x, y, z; for (x in x = ", " = z = {});"},
+      {"var x, y, z; for (x of ", " = z = {});"},
+      {"var x, y, z; for (x of x = ", " = z = {});"},
       {NULL, NULL}};
 
   // clang-format off
   const char* data[] = {
     "x",
 
     "{ x : y }",
     "{ x : foo().y }",
     "{ x : foo()[y] }",
     "{ x : y.z }",
@@ skipping 53 matching lines @@
     "[ { x : y = 10 } = {} ]",
     "[ { x : foo().y = 10 } = {} ]",
     "[ { x : foo()[y] = 10 } = {} ]",
     "[ { x : x.y = 10 } = {} ]",
     "[ { x : x[y] = 10 } = {} ]",
     "[ [ x = 10 ] = {} ]",
     "[ [ foo().x = 10 ] = {} ]",
     "[ [ foo()[x] = 10 ] = {} ]",
     "[ [ x.y = 10 ] = {} ]",
     "[ [ x[y] = 10 ] = {} ]",
-
-    "{ x : y }",
     "{ x : y = 1 }",
     "{ x }",
     "{ x, y, z }",
     "{ x = 1, y: z, z: y }",
     "{x = 42, y = 15}",
     "[x]",
     "[x = 1]",
     "[x,y,z]",
     "[x, y = 42, z]",
     "{ x : x, y : y }",
@@ skipping 22 matching lines @@
     "{[foo()] : (z)}",
     "{[foo()] : foo().bar}",
     "{[foo()] : foo()['bar']}",
     "{[foo()] : this.bar}",
     "{[foo()] : this['bar']}",
     "{[foo()] : 'foo'.bar}",
     "{[foo()] : 'foo'['bar']}",
     "[...x]",
     "[x,y,...z]",
     "[x,,...z]",
-    "{ x: y } = z",
-    "[x, y] = z",
-    "{ x: y } = { z }",
-    "[x, y] = { z }",
-    "{ x: y } = [ z ]",
-    "[x, y] = [ z ]",
+    "{ x: y }",
+    "[x, y]",
     "[((x, y) => z).x]",
     "{x: ((y, z) => z).x}",
     "[((x, y) => z)['x']]",
     "{x: ((y, z) => z)['x']}",
 
     "{x: { y = 10 } }",
     "[(({ x } = { x: 1 }) => x).a]",
     NULL};
   // clang-format on
   static const ParserFlag always_flags[] = {
       kAllowHarmonyDestructuringAssignment, kAllowHarmonyDestructuring,
       kAllowHarmonyDefaultParameters};
   RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
                     arraysize(always_flags));
 
+  RunParserSyncTest(mixed_assignments_context_data, data, kSuccess, NULL, 0,
+                    always_flags, arraysize(always_flags));
+
   const char* empty_context_data[][2] = {
       {"'use strict';", ""}, {"", ""}, {NULL, NULL}};
 
   // CoverInitializedName ambiguity handling in various contexts
   const char* ambiguity_data[] = {
       "var foo = { x = 10 } = {};",
       "var foo = { q } = { x = 10 } = {};",
       "var foo; foo = { x = 10 } = {};",
       "var foo; foo = { q } = { x = 10 } = {};",
       "var x; ({ x = 10 } = {});",
@@ skipping 769 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));
 }
+
+
+TEST(MiscSyntaxErrors) {
+  const char* context_data[][2] = {
+      {"'use strict'", ""}, {"", ""}, {NULL, NULL}};
+  const char* error_data[] = {"for (();;) {}", NULL};
+
+  RunParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0);
+}