Enable early reference errors for most assignments to invalid LHS

pleath · pleath · commit 13847da1662c · 2018-06-04T10:33:36.000-07:00
diff --git a/lib/Common/ConfigFlagsList.h b/lib/Common/ConfigFlagsList.h
@@ -30,6 +30,7 @@ PHASE(All)
         PHASE(ScanAhead)
         PHASE_DEFAULT_OFF(ParallelParse)
         PHASE(EarlyReferenceErrors)
+        PHASE(EarlyErrorOnAssignToCall)
         PHASE(BgParse)
     PHASE(ByteCode)
         PHASE(CachedScope)
diff --git a/lib/Parser/Parse.cpp b/lib/Parser/Parse.cpp
@@ -2488,7 +2488,7 @@ ParseNodePtr Parser::ParseImport()
         ParseNodePtr pnode = ParseImportCall<buildAST>();
         BOOL fCanAssign;
         IdentToken token;
-        return ParsePostfixOperators<buildAST>(pnode, TRUE, FALSE, FALSE, &fCanAssign, &token);
+        return ParsePostfixOperators<buildAST>(pnode, TRUE, FALSE, FALSE, TRUE, &fCanAssign, &token);
     }
 
     this->GetScanner()->SeekTo(parsedImport);
@@ -2917,6 +2917,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
     uint32 *pShortNameOffset,
     _Inout_opt_ IdentToken* pToken /*= nullptr*/,
     bool fUnaryOrParen /*= false*/,
+    BOOL fCanAssignToCall /*= TRUE*/,
     _Out_opt_ BOOL* pfCanAssign /*= nullptr*/,
     _Inout_opt_ BOOL* pfLikelyPattern /*= nullptr*/,
     _Out_opt_ bool* pfIsDotOrIndex /*= nullptr*/,
@@ -3255,7 +3256,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
         }
         else
         {
-            ParseNodePtr pnodeExpr = ParseTerm<buildAST>(FALSE, pNameHint, pHintLength, pShortNameOffset, nullptr, false, nullptr, nullptr, nullptr, plastRParen);
+            ParseNodePtr pnodeExpr = ParseTerm<buildAST>(FALSE, pNameHint, pHintLength, pShortNameOffset, nullptr, false, TRUE, nullptr, nullptr, nullptr, plastRParen);
             if (buildAST)
             {
                 pnode = CreateCallNode(knopNew, pnodeExpr, nullptr);
@@ -3413,7 +3414,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
         break;
     }
 
-    pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, isAsyncExpr, &fCanAssign, &term, pfIsDotOrIndex);
+    pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, isAsyncExpr, fCanAssignToCall, &fCanAssign, &term, pfIsDotOrIndex);
 
     if (savedTopAsyncRef != nullptr &&
         this->m_token.tk == tkDArrow)
@@ -3528,6 +3529,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
     BOOL fAllowCall,
     BOOL fInNew,
     BOOL isAsyncExpr,
+    BOOL fCanAssignToCallResult,
     BOOL *pfCanAssign,
     _Inout_ IdentToken* pToken,
     _Out_opt_ bool* pfIsDotOrIndex /*= nullptr */)
@@ -3671,7 +3673,10 @@ ParseNodePtr Parser::ParsePostfixOperators(
             }
             if (pfCanAssign)
             {
-                *pfCanAssign = FALSE;
+                *pfCanAssign = fCanAssignToCallResult && 
+                               (m_sourceContextInfo ?
+                                !PHASE_ON_RAW(Js::EarlyErrorOnAssignToCallPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId) :
+                                !PHASE_ON1(Js::EarlyErrorOnAssignToCallPhase));
             }
             if (pfIsDotOrIndex)
             {
@@ -4547,7 +4552,7 @@ ParseNodePtr Parser::ParseMemberList(LPCOLESTR pNameHint, uint32* pNameHintLengt
                     // First identify that the current expression is indeed the object/array literal. Otherwise we will just use the ParsrExpr to parse that.
 
                     ParseTerm<buildAST>(/* fAllowCall */ m_token.tk != tkSUPER, nullptr /*pNameHint*/, nullptr /*pHintLength*/, nullptr /*pShortNameOffset*/, &token, false /*fUnaryOrParen*/,
-                        nullptr /*pfCanAssign*/, &fLikelyPattern);
+                        TRUE, nullptr /*pfCanAssign*/, &fLikelyPattern);
 
                     this->GetScanner()->SeekTo(atExpression);
 
@@ -8408,6 +8413,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
     RestorePoint termStart;
     uint32 hintLength = 0;
     uint32 hintOffset = 0;
+    BOOL fLikelyPattern = FALSE;
 
     ParserState parserState;
 
@@ -8508,7 +8514,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
         {
             if ((nop == knopIncPre || nop == knopDecPre) && (m_token.tk != tkDArrow))
             {
-                if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))
+                if (!fCanAssign && 
+                    (m_sourceContextInfo 
+                     ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)
+                     : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))
                 {
                     Error(JSERR_CantAssignTo);
                 }
@@ -8604,8 +8613,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
     else
     {
         ichMin = this->GetScanner()->IchMinTok();
-        BOOL fLikelyPattern = FALSE;
-        pnode = ParseTerm<buildAST>(TRUE, pNameHint, &hintLength, &hintOffset, &term, fUnaryOrParen, &fCanAssign, IsES6DestructuringEnabled() ? &fLikelyPattern : nullptr, &fIsDotOrIndex, plastRParen);
+        pnode = ParseTerm<buildAST>(TRUE, pNameHint, &hintLength, &hintOffset, &term, fUnaryOrParen, TRUE, &fCanAssign, IsES6DestructuringEnabled() ? &fLikelyPattern : nullptr, &fIsDotOrIndex, plastRParen);
         if (pfLikelyPattern != nullptr)
         {
             *pfLikelyPattern = !!fLikelyPattern;
@@ -8680,7 +8688,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
         if (!this->GetScanner()->FHadNewLine() &&
             (tkInc == m_token.tk || tkDec == m_token.tk))
         {
-            if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))
+            if (!fCanAssign && 
+                (m_sourceContextInfo 
+                 ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)
+                 : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))
             {
                 Error(JSERR_CantAssignTo);
             }
@@ -8764,7 +8775,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
             {
                 break;
             }
-            if (m_token.tk != tkDArrow && !fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))
+            if (m_token.tk != tkDArrow && !fCanAssign && 
+                (m_sourceContextInfo 
+                 ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)
+                 : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))
             {
                 Error(JSERR_CantAssignTo);
                 // No recovery necessary since this is a semantic, not structural, error.
@@ -8789,7 +8803,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
 
         // Precedence is high enough. Consume the operator token.
         this->GetScanner()->Scan();
-        fCanAssign = FALSE;
+        fCanAssign = !!fLikelyPattern;
 
         // Special case the "?:" operator
         if (nop == knopQmark)
@@ -9896,7 +9910,10 @@ ParseNodePtr Parser::ParseStatement()
                     Error(ERRForInNoInitAllowed);
                 }
             }
-            if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))
+            if (!fCanAssign && 
+                (m_sourceContextInfo 
+                 ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)
+                 : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))
             {
                 Error(JSERR_CantAssignTo);
             }
@@ -12723,7 +12740,7 @@ ParseNodePtr Parser::ParseDestructuredVarDecl(tokens declarationType, bool isDec
             BOOL fCanAssign;
             IdentToken token;
             // Look for postfix operator
-            pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, FALSE, &fCanAssign, &token);
+            pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, FALSE, TRUE, &fCanAssign, &token);
         }
     }
     else if (m_token.tk == tkSUPER || m_token.tk == tkID || m_token.tk == tkTHIS)
@@ -12741,7 +12758,7 @@ ParseNodePtr Parser::ParseDestructuredVarDecl(tokens declarationType, bool isDec
             IdentToken token;
             // We aren't declaring anything, so scan the ID reference manually.
             pnodeElem = ParseTerm<buildAST>(/* fAllowCall */ m_token.tk != tkSUPER, nullptr /*pNameHint*/, nullptr /*pHintLength*/, nullptr /*pShortNameOffset*/, &token, false,
-                &fCanAssign);
+                FALSE, &fCanAssign);
 
             // In this destructuring case we can force error here as we cannot assign.
 
diff --git a/lib/Parser/Parse.h b/lib/Parser/Parse.h
@@ -876,6 +876,7 @@ class Parser
         uint32 *pShortNameOffset = nullptr,
         _Inout_opt_ IdentToken* pToken = nullptr,
         bool fUnaryOrParen = false,
+        BOOL fCanAssignToCall = TRUE,
         _Out_opt_ BOOL* pfCanAssign = nullptr,
         _Inout_opt_ BOOL* pfLikelyPattern = nullptr,
         _Out_opt_ bool* pfIsDotOrIndex = nullptr,
@@ -886,6 +887,7 @@ class Parser
         BOOL fAllowCall, 
         BOOL fInNew, 
         BOOL isAsyncExpr,
+        BOOL fCanAssignToCallResult,
         BOOL *pfCanAssign, 
         _Inout_ IdentToken* pToken, 
         _Out_opt_ bool* pfIsDotOrIndex = nullptr);
diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -6893,7 +6893,6 @@ void EmitAssignment(
         break;
 
     default:
-        Assert(!PHASE_ON1(Js::EarlyReferenceErrorsPhase));
         byteCodeGenerator->Writer()->W1(Js::OpCode::RuntimeReferenceError, SCODE_CODE(JSERR_CantAssignTo));
         break;
     }
diff --git a/test/Bugs/rlexe.xml b/test/Bugs/rlexe.xml
@@ -55,7 +55,7 @@
     <default>
       <files>randombug.js</files>
       <baseline>randombug.baseline</baseline>
-      <compile-flags>-CollectGarbage -ExtendedErrorStackForTestHost</compile-flags>
+      <compile-flags>-CollectGarbage -ExtendedErrorStackForTestHost -off:earlyreferenceerrors</compile-flags>
     </default>
   </test>
   <test>
diff --git a/test/Optimizer/rlexe.xml b/test/Optimizer/rlexe.xml
@@ -1462,7 +1462,7 @@
   <test>
     <default>
       <files>test146.js</files>
-      <compile-flags>-off:bailonnoprofile</compile-flags>
+      <compile-flags>-off:bailonnoprofile -off:earlyreferenceerrors</compile-flags>
     </default>
   </test>
   <test>
diff --git a/test/bailout/rlexe.xml b/test/bailout/rlexe.xml
@@ -206,6 +206,7 @@
   <test>
     <default>
       <files>implicit_nosideeffect.js</files>
+      <compile-flags>-off:earlyreferenceerrors</compile-flags>
       <baseline>implicit_nosideeffect.baseline</baseline>
     </default>
   </test>
diff --git a/test/es6/destructuring_obj.js b/test/es6/destructuring_obj.js
@@ -142,7 +142,7 @@ var tests = [
       assert.doesNotThrow(function () { eval("let a; ({a:((((a1))))} = {a:20})"); }, "Object expression pattern with parens is valid syntax");
       assert.doesNotThrow(function () { eval("let a, r1; ({a:a1 = r1} = {})"); }, "Object expression pattern with defaults as reference is valid syntax");
       assert.doesNotThrow(function () { eval("let a, r1; ({a:a1 = r1 = 44} = {})"); }, "Object expression pattern with chained assignments as defaults is valid syntax");
-      assert.throws(function () { eval("let a, r1; ({a:(a1 = r1) = 44} = {})"); }, SyntaxError, "Object expression pattern with chained assignments but paren in between is not valid syntax", "Expected ')'");
+      assert.throws(function () { eval("let a, r1; ({a:(a1 = r1) = 44} = {})"); }, ReferenceError, "Object expression pattern with chained assignments but paren in between is not valid syntax", "Invalid left-hand side in assignment");
       assert.doesNotThrow(function () { eval("var a; `${({a} = {})}`"); }, "Object expression pattern inside a string template is valid syntax");
       assert.throws(function () { eval("for (let {x} = {} of []) {}"); }, SyntaxError, "for.of has declaration pattern with initializer is not valid syntax", "for-of loop head declarations cannot have an initializer");
       assert.throws(function () { eval("for (let {x} = {} in []) {}"); }, SyntaxError, "for.in has declaration pattern with initializer is not valid syntax", "for-in loop head declarations cannot have an initializer");
diff --git a/test/loop/rlexe.xml b/test/loop/rlexe.xml
@@ -3,14 +3,14 @@
   <test>
     <default>
       <files>loop.js</files>
-      <compile-flags>-forcejitloopbody</compile-flags>
+      <compile-flags>-forcejitloopbody -off:earlyreferenceerrors</compile-flags>
       <baseline>loop.baseline</baseline>
     </default>
   </test>
   <test>
     <default>
       <files>loop.js</files>
-      <compile-flags>-forcejitloopbody -on:interruptprobe</compile-flags>
+      <compile-flags>-forcejitloopbody -on:interruptprobe -off:earlyreferenceerrors</compile-flags>
       <baseline>loop.baseline</baseline>
     </default>
   </test>

Original file line number	Diff line number	Diff line change
`@@ -2488,7 +2488,7 @@ ParseNodePtr Parser::ParseImport()`
`2488`	`2488`	`ParseNodePtr pnode = ParseImportCall<buildAST>();`
`2489`	`2489`	`BOOL fCanAssign;`
`2490`	`2490`	`IdentToken token;`
`2491`		`- return ParsePostfixOperators<buildAST>(pnode, TRUE, FALSE, FALSE, &fCanAssign, &token);`
	`2491`	`+ return ParsePostfixOperators<buildAST>(pnode, TRUE, FALSE, FALSE, TRUE, &fCanAssign, &token);`
`2492`	`2492`	`}`
`2493`	`2493`
`2494`	`2494`	`this->GetScanner()->SeekTo(parsedImport);`
`@@ -2917,6 +2917,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,`
`2917`	`2917`	`uint32 *pShortNameOffset,`
`2918`	`2918`	`_Inout_opt_ IdentToken* pToken /= nullptr/,`
`2919`	`2919`	`bool fUnaryOrParen /= false/,`
	`2920`	`+ BOOL fCanAssignToCall /= TRUE/,`
`2920`	`2921`	`_Out_opt_ BOOL* pfCanAssign /= nullptr/,`
`2921`	`2922`	`_Inout_opt_ BOOL* pfLikelyPattern /= nullptr/,`
`2922`	`2923`	`_Out_opt_ bool* pfIsDotOrIndex /= nullptr/,`
`@@ -3255,7 +3256,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,`
`3255`	`3256`	`}`
`3256`	`3257`	`else`
`3257`	`3258`	`{`
`3258`		`- ParseNodePtr pnodeExpr = ParseTerm<buildAST>(FALSE, pNameHint, pHintLength, pShortNameOffset, nullptr, false, nullptr, nullptr, nullptr, plastRParen);`
	`3259`	`+ ParseNodePtr pnodeExpr = ParseTerm<buildAST>(FALSE, pNameHint, pHintLength, pShortNameOffset, nullptr, false, TRUE, nullptr, nullptr, nullptr, plastRParen);`
`3259`	`3260`	`if (buildAST)`
`3260`	`3261`	`{`
`3261`	`3262`	`pnode = CreateCallNode(knopNew, pnodeExpr, nullptr);`
`@@ -3413,7 +3414,7 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,`
`3413`	`3414`	`break;`
`3414`	`3415`	`}`
`3415`	`3416`
`3416`		`- pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, isAsyncExpr, &fCanAssign, &term, pfIsDotOrIndex);`
	`3417`	`+ pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, isAsyncExpr, fCanAssignToCall, &fCanAssign, &term, pfIsDotOrIndex);`
`3417`	`3418`
`3418`	`3419`	`if (savedTopAsyncRef != nullptr &&`
`3419`	`3420`	`this->m_token.tk == tkDArrow)`
`@@ -3528,6 +3529,7 @@ ParseNodePtr Parser::ParsePostfixOperators(`
`3528`	`3529`	`BOOL fAllowCall,`
`3529`	`3530`	`BOOL fInNew,`
`3530`	`3531`	`BOOL isAsyncExpr,`
	`3532`	`+ BOOL fCanAssignToCallResult,`
`3531`	`3533`	`BOOL *pfCanAssign,`
`3532`	`3534`	`_Inout_ IdentToken* pToken,`
`3533`	`3535`	`_Out_opt_ bool* pfIsDotOrIndex /= nullptr /)`
`@@ -3671,7 +3673,10 @@ ParseNodePtr Parser::ParsePostfixOperators(`
`3671`	`3673`	`}`
`3672`	`3674`	`if (pfCanAssign)`
`3673`	`3675`	`{`
`3674`		`- *pfCanAssign = FALSE;`
	`3676`	`+ *pfCanAssign = fCanAssignToCallResult &&`
	`3677`	`+ (m_sourceContextInfo ?`
	`3678`	`+ !PHASE_ON_RAW(Js::EarlyErrorOnAssignToCallPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId) :`
	`3679`	`+ !PHASE_ON1(Js::EarlyErrorOnAssignToCallPhase));`
`3675`	`3680`	`}`
`3676`	`3681`	`if (pfIsDotOrIndex)`
`3677`	`3682`	`{`
`@@ -4547,7 +4552,7 @@ ParseNodePtr Parser::ParseMemberList(LPCOLESTR pNameHint, uint32* pNameHintLengt`
`4547`	`4552`	`// First identify that the current expression is indeed the object/array literal. Otherwise we will just use the ParsrExpr to parse that.`
`4548`	`4553`
`4549`	`4554`	`ParseTerm<buildAST>(/* fAllowCall / m_token.tk != tkSUPER, nullptr /pNameHint/, nullptr /pHintLength/, nullptr /pShortNameOffset/, &token, false /fUnaryOrParen*/,`
`4550`		`- nullptr /pfCanAssign/, &fLikelyPattern);`
	`4555`	`+ TRUE, nullptr /pfCanAssign/, &fLikelyPattern);`
`4551`	`4556`
`4552`	`4557`	`this->GetScanner()->SeekTo(atExpression);`
`4553`	`4558`
`@@ -8408,6 +8413,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8408`	`8413`	`RestorePoint termStart;`
`8409`	`8414`	`uint32 hintLength = 0;`
`8410`	`8415`	`uint32 hintOffset = 0;`
	`8416`	`+ BOOL fLikelyPattern = FALSE;`
`8411`	`8417`
`8412`	`8418`	`ParserState parserState;`
`8413`	`8419`
`@@ -8508,7 +8514,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8508`	`8514`	`{`
`8509`	`8515`	`if ((nop == knopIncPre \|\| nop == knopDecPre) && (m_token.tk != tkDArrow))`
`8510`	`8516`	`{`
`8511`		`- if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))`
	`8517`	`+ if (!fCanAssign &&`
	`8518`	`+ (m_sourceContextInfo`
	`8519`	`+ ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)`
	`8520`	`+ : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))`
`8512`	`8521`	`{`
`8513`	`8522`	`Error(JSERR_CantAssignTo);`
`8514`	`8523`	`}`
`@@ -8604,8 +8613,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8604`	`8613`	`else`
`8605`	`8614`	`{`
`8606`	`8615`	`ichMin = this->GetScanner()->IchMinTok();`
`8607`		`- BOOL fLikelyPattern = FALSE;`
`8608`		`- pnode = ParseTerm<buildAST>(TRUE, pNameHint, &hintLength, &hintOffset, &term, fUnaryOrParen, &fCanAssign, IsES6DestructuringEnabled() ? &fLikelyPattern : nullptr, &fIsDotOrIndex, plastRParen);`
	`8616`	`+ pnode = ParseTerm<buildAST>(TRUE, pNameHint, &hintLength, &hintOffset, &term, fUnaryOrParen, TRUE, &fCanAssign, IsES6DestructuringEnabled() ? &fLikelyPattern : nullptr, &fIsDotOrIndex, plastRParen);`
`8609`	`8617`	`if (pfLikelyPattern != nullptr)`
`8610`	`8618`	`{`
`8611`	`8619`	`*pfLikelyPattern = !!fLikelyPattern;`
`@@ -8680,7 +8688,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8680`	`8688`	`if (!this->GetScanner()->FHadNewLine() &&`
`8681`	`8689`	`(tkInc == m_token.tk \|\| tkDec == m_token.tk))`
`8682`	`8690`	`{`
`8683`		`- if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))`
	`8691`	`+ if (!fCanAssign &&`
	`8692`	`+ (m_sourceContextInfo`
	`8693`	`+ ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)`
	`8694`	`+ : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))`
`8684`	`8695`	`{`
`8685`	`8696`	`Error(JSERR_CantAssignTo);`
`8686`	`8697`	`}`
`@@ -8764,7 +8775,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8764`	`8775`	`{`
`8765`	`8776`	`break;`
`8766`	`8777`	`}`
`8767`		`- if (m_token.tk != tkDArrow && !fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))`
	`8778`	`+ if (m_token.tk != tkDArrow && !fCanAssign &&`
	`8779`	`+ (m_sourceContextInfo`
	`8780`	`+ ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)`
	`8781`	`+ : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))`
`8768`	`8782`	`{`
`8769`	`8783`	`Error(JSERR_CantAssignTo);`
`8770`	`8784`	`// No recovery necessary since this is a semantic, not structural, error.`
`@@ -8789,7 +8803,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8789`	`8803`
`8790`	`8804`	`// Precedence is high enough. Consume the operator token.`
`8791`	`8805`	`this->GetScanner()->Scan();`
`8792`		`- fCanAssign = FALSE;`
	`8806`	`+ fCanAssign = !!fLikelyPattern;`
`8793`	`8807`
`8794`	`8808`	`// Special case the "?:" operator`
`8795`	`8809`	`if (nop == knopQmark)`
`@@ -9896,7 +9910,10 @@ ParseNodePtr Parser::ParseStatement()`
`9896`	`9910`	`Error(ERRForInNoInitAllowed);`
`9897`	`9911`	`}`
`9898`	`9912`	`}`
`9899`		`- if (!fCanAssign && PHASE_ON1(Js::EarlyReferenceErrorsPhase))`
	`9913`	`+ if (!fCanAssign &&`
	`9914`	`+ (m_sourceContextInfo`
	`9915`	`+ ? !PHASE_OFF_RAW(Js::EarlyReferenceErrorsPhase, m_sourceContextInfo->sourceContextId, GetCurrentFunctionNode()->functionId)`
	`9916`	`+ : !PHASE_OFF1(Js::EarlyReferenceErrorsPhase)))`
`9900`	`9917`	`{`
`9901`	`9918`	`Error(JSERR_CantAssignTo);`
`9902`	`9919`	`}`
`@@ -12723,7 +12740,7 @@ ParseNodePtr Parser::ParseDestructuredVarDecl(tokens declarationType, bool isDec`
`12723`	`12740`	`BOOL fCanAssign;`
`12724`	`12741`	`IdentToken token;`
`12725`	`12742`	`// Look for postfix operator`
`12726`		`- pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, FALSE, &fCanAssign, &token);`
	`12743`	`+ pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, FALSE, TRUE, &fCanAssign, &token);`
`12727`	`12744`	`}`
`12728`	`12745`	`}`
`12729`	`12746`	`else if (m_token.tk == tkSUPER \|\| m_token.tk == tkID \|\| m_token.tk == tkTHIS)`
`@@ -12741,7 +12758,7 @@ ParseNodePtr Parser::ParseDestructuredVarDecl(tokens declarationType, bool isDec`
`12741`	`12758`	`IdentToken token;`
`12742`	`12759`	`// We aren't declaring anything, so scan the ID reference manually.`
`12743`	`12760`	`pnodeElem = ParseTerm<buildAST>(/* fAllowCall / m_token.tk != tkSUPER, nullptr /pNameHint/, nullptr /pHintLength/, nullptr /pShortNameOffset*/, &token, false,`
`12744`		`- &fCanAssign);`
	`12761`	`+ FALSE, &fCanAssign);`
`12745`	`12762`
`12746`	`12763`	`// In this destructuring case we can force error here as we cannot assign.`
`12747`	`12764`
Original file line number	Diff line number	Diff line change
`@@ -6893,7 +6893,6 @@ void EmitAssignment(`
`6893`	`6893`	`break;`
`6894`	`6894`
`6895`	`6895`	`default:`
`6896`		`- Assert(!PHASE_ON1(Js::EarlyReferenceErrorsPhase));`
`6897`	`6896`	`byteCodeGenerator->Writer()->W1(Js::OpCode::RuntimeReferenceError, SCODE_CODE(JSERR_CantAssignTo));`
`6898`	`6897`	`break;`
`6899`	`6898`	`}`