Report parse error on illegal LHS of += and similar operators.

The code snippet should produce a closure compiler parse error instead of a runtime crash (regardless of optimization mode).

```
for ( ....; .... ; [i,j]  +=  [j, j+1]) { ... }
```

On chrome, this gives:

Uncaught SyntaxError: Invalid left-hand side in assignment

PiperOrigin-RevId: 498162532

Author: rishipal

src/com/google/javascript/jscomp/parsing/parser/Parser.java

@@ -2352,6 +2352,14 @@ private ParseTree parseAssignment(Expression expressionIn) {
     }
 
     if (peekAssignmentOperator()) {
+      if (!peek(TokenType.EQUAL)) {
+        // not the vanilla assignment operator `=`, but a special equals operator (`+=`, `-=`,
+        // `**=`, etc)
+        if (!left.isValidNonVanillaAssignmentTarget()) {
+          reportError("invalid assignment target");
+          return new MissingPrimaryExpressionTree(getTreeLocation(getTreeStartLocation()));
+        }
+      }
       left = transformLeftHandSideExpression(left);
       if (!left.isValidAssignmentTarget()) {
         reportError("invalid assignment target");

src/com/google/javascript/jscomp/parsing/parser/trees/ParseTree.java

@@ -216,6 +216,27 @@ public boolean isPattern() {
     }
   }
 
+  /** Is valid assignment target for non-vanilla assignment operators like `+=`, `-+`, `**=`, etc */
+  public boolean isValidNonVanillaAssignmentTarget() {
+    ParseTree parseTree = this;
+    while (parseTree.type == ParseTreeType.PAREN_EXPRESSION) {
+      parseTree = parseTree.asParenExpression().expression;
+    }
+    switch (parseTree.type) {
+      case IDENTIFIER_EXPRESSION:
+      case MEMBER_EXPRESSION:
+      case MEMBER_LOOKUP_EXPRESSION:
+      case DEFAULT_PARAMETER:
+        return true;
+      case ARRAY_PATTERN:
+      case OBJECT_PATTERN:
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  /** Is valid assignment target for any assignment operator like `=`, `+=`, `-+`, `**=`, etc */
   public boolean isValidAssignmentTarget() {
     ParseTree parseTree = this;
     while (parseTree.type == ParseTreeType.PAREN_EXPRESSION) {

test/com/google/javascript/jscomp/parsing/ParserTest.java

@@ -3097,6 +3097,25 @@ public void testArrayDestructuringVar() {
     parse("var [x,y] = foo();");
   }
 
+  @Test
+  public void testLHSOfNonVanillaEqualsOperator() {
+    strictMode = SLOPPY;
+    mode = LanguageMode.ECMASCRIPT_2015;
+
+    // object pattern or array pattern on the lhs of vanilla equals passes
+    parse("for (let [i,j] = [2,0]; j < 2; [i,j]  =  [j, j+1]) {}");
+    parse("for (let [i,j] = [2,0]; j < 2; {i,j}  =  [j, j+1]) {}");
+
+    // error with object pattern or array pattern on the lhs of +=
+    parseError(
+        "for (let [i,j] = [2,0]; j < 2; [i,j]  +=  [j, j+1]) {}", "invalid assignment target");
+    parseError(
+        "for (let [i,j] = [2,0]; j < 2; {i,j}  +=  [j, j+1]) {}", "invalid assignment target");
+
+    parse("let [i,j]  =  [2, 2];");
+    parseError("let [i,j]  +=  [2, 2];", "destructuring must have an initializer");
+  }
+
   @Test
   public void testArrayDestructuringVarInvalid() {
     // arbitrary LHS assignment target not allowed