[MERGE #6281 @zenparsing] Throw invalid LHS errors at parse time

Merge pull request #6281 from zenparsing:early-lhs-errors

Fixes #6278

This PR sets the `fCanAssign` flag to false for array literals, object literals, `new` meta properties, `this`, and `super`. It relies on the caller to reset their `fCanAssign` flags to true if they end up parsing a destructuring assignment pattern.

Author: Kevin Smith

lib/Parser/Parse.cpp

@@ -3352,6 +3352,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
 
         pid = ParseSuper<buildAST>(!!fAllowCall);
         isSpecialName = true;
+        fCanAssign = FALSE;
 
         // Super reference and super call need to push a pid ref to 'this' even when not building an AST
         ReferenceSpecialName(wellKnownPropertyPids._this, ichMin, ichLim);
@@ -3376,6 +3377,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
 
         this->GetScanner()->Scan();
         isSpecialName = true;
+        fCanAssign = FALSE;
 
         goto LIdentifier;
 
@@ -3581,6 +3583,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
 
             this->GetScanner()->Scan();
             isSpecialName = true;
+            fCanAssign = FALSE;
 
             goto LIdentifier;
         }
@@ -3617,14 +3620,11 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
             this->m_funcInArrayDepth = 0;
         }
         ChkCurTok(tkRBrack, ERRnoRbrack);
-        if (!IsES6DestructuringEnabled())
-        {
-            fCanAssign = FALSE;
-        }
-        else if (pfLikelyPattern != nullptr && !IsPostFixOperators())
+        if (IsES6DestructuringEnabled() && pfLikelyPattern != nullptr && !IsPostFixOperators())
         {
             *pfLikelyPattern = TRUE;
         }
+        fCanAssign = FALSE;
         break;
     }
 
@@ -3640,14 +3640,11 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
             pnode->ichLim = this->GetScanner()->IchLimTok();
         }
         ChkCurTok(tkRCurly, ERRnoRcurly);
-        if (!IsES6DestructuringEnabled())
-        {
-            fCanAssign = FALSE;
-        }
-        else if (pfLikelyPattern != nullptr && !IsPostFixOperators())
+        if (IsES6DestructuringEnabled() && pfLikelyPattern != nullptr && !IsPostFixOperators())
         {
             *pfLikelyPattern = TRUE;
         }
+        fCanAssign = FALSE;
         break;
     }
 
@@ -9055,6 +9052,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
             m_nextBlockId = parserState.m_nextBlockId;
 
             ParseDestructuredLiteralWithScopeSave(tkLCurly, false/*isDecl*/, false /*topLevel*/, DIC_ShouldNotParseInitializer);
+            fCanAssign = TRUE;
 
             // Restore the Block ID at the end of the reparsing so it matches the one at the end of the first pass. We need to do this 
             // because we don't parse initializers during reparse and there may be additional blocks (e.g. a class declaration)
@@ -10409,6 +10407,7 @@ ParseNodePtr Parser::ParseStatement()
             {
                 this->GetScanner()->SeekTo(exprStart);
                 ParseDestructuredLiteralWithScopeSave(tkNone, false/*isDecl*/, false /*topLevel*/, DIC_None, false /*allowIn*/);
+                fCanAssign = TRUE;
 
                 if (buildAST)
                 {

test/Basics/SpecialSymbolCapture.js

@@ -215,6 +215,26 @@ var tests = [
             `);
         }
     },
+    {
+        name: "Special names are invalid assignment targets",
+        body: function () {
+            assert.throws(() => eval(`
+                function f() {
+                    if (0) new.target = 1;
+                }
+            `), ReferenceError, "", "Invalid left-hand side in assignment");
+            assert.throws(() => eval(`
+                function f() {
+                    if (0) this = 1;
+                }
+            `), ReferenceError, "", "Invalid left-hand side in assignment");
+            assert.throws(() => eval(`
+                function f() {
+                    if (0) super = 1;
+                }
+            `), SyntaxError, "", "Invalid use of the 'super' keyword");
+        }
+    },
     {
         name: "Global-scope `new.target` keyword is early syntax error",
         body: function () {

test/es6/destructuring_bugs.js

@@ -367,10 +367,6 @@ var tests = [
   {
     name: "Destructuring pattern at param has nested blocks.",
     body: function () {
-        assert.doesNotThrow(function () { eval("var e = 1;       ( {abcdef  = ((((({})) = (1))))} = (e)) => {  try{ } catch(e) {}}") }, "Should not throw when the default value and it's initializer both have extra parentheses.");
-
-        assert.doesNotThrow(function () { eval("var e = 1;       ( {ghijkl  = ((((({})) =  1 )))} = (e)) => {  try{ } catch(e) {}}") }, "Should not throw when the default value has extra parentheses.");
-
         assert.doesNotThrow(function () { eval("var e = 1; ( {mnopqrs = (((  {}   = (1))))} = (e)) => {  try{ } catch(e) {}}") }, "Should not throw when the default value initializer has extra parentheses.");
 
         assert.doesNotThrow(function () { eval("var e = 1; ( {tuvwxy  = (((  {}   =  1 )))} = (e)) => {  try{ } catch(e) {}}") }, "Should not throw when the default value and initializer are wrapped in extra parentheses.");
@@ -509,6 +505,17 @@ var tests = [
         test1();
     }
   },
+  {
+    name: "Invalid destructuring patterns should be early errors",
+    body: function () {
+        assert.throws(function () {
+            eval("if (false) { [11] += [1, 2, 3] }");
+        }, ReferenceError, "", "Invalid left-hand side in assignment");
+        assert.throws(function () {
+            eval("if (false) { [11] = [1, 2, 3] }");
+        }, SyntaxError, "", "Destructuring expressions can only have identifier references");
+    }
+  },
   {
     name: "Destructuring expression : Array expression instead of name ",
     body: function () {