[1.7>master] [1.6>1.7] [MERGE #3409 @curtisman] Fix Issue #3376: Escaped yield cannot be an identifier in strict mode

curtisman · curtisman · commit d2cb4ebaf6d7 · 2017-07-21T11:59:12.000-07:00
Merge pull request #3409 from curtisman:fix3376 The unescape ID scanning fast path already have the check for strict mode for yield. Refactor the logic and share it with escaped ID scanning code path. Also fixed the escaped await used as ID in module case as well.
diff --git a/lib/Parser/JsScan.js b/lib/Parser/JsScan.js
@@ -15,14 +15,14 @@ function emitToken(token, d, indent) {
         r += indent + "p += " + d + ";\r\n";
     if (token.res == 1) {
         if (token.tk === "tkYIELD") {
-            r += indent + "if (this->m_fYieldIsKeyword || !this->m_parser || this->m_parser->IsStrictMode()) {" + "\r\n";
+            r += indent + "if (this->YieldIsKeyword()) {" + "\r\n";
             r += indent + "    token = " + token.tk + ";\r\n";
             r += indent + "    goto LReserved;\r\n";
             r += indent + "}\r\n";
             r += indent + "goto LIdentifier;\r\n";
         } else if (token.tk === "tkAWAIT") {
             // Note: `await` is only a FutureReservedWord when parsing module scripts (when Module is goal symbol of the grammar)
-            r += indent + "if (this->m_fAwaitIsKeyword || this->m_fIsModuleCode) {" + "\r\n";
+            r += indent + "if (this->AwaitIsKeyword()) {" + "\r\n";
             r += indent + "    token = " + token.tk + ";\r\n";
             r += indent + "    goto LReserved;\r\n";
             r += indent + "}\r\n";
diff --git a/lib/Parser/Parse.cpp b/lib/Parser/Parse.cpp
@@ -256,8 +256,8 @@ HRESULT Parser::ValidateSyntax(LPCUTF8 pszSrc, size_t encodedCharCount, bool isG
 
         // Give the scanner the source and get the first token
         m_pscan->SetText(pszSrc, 0, encodedCharCount, 0, grfscr);
-        m_pscan->SetYieldIsKeyword(isGenerator);
-        m_pscan->SetAwaitIsKeyword(isAsync);
+        m_pscan->SetYieldIsKeywordRegion(isGenerator);
+        m_pscan->SetAwaitIsKeywordRegion(isAsync);
         m_pscan->Scan();
 
         uint nestedCount = 0;
@@ -2929,9 +2929,9 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
             isAsyncExpr = true;
         }
 
-        bool previousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(isAsyncExpr);
+        bool previousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(isAsyncExpr);
         m_pscan->Scan();
-        m_pscan->SetAwaitIsKeyword(previousAwaitIsKeyword);
+        m_pscan->SetAwaitIsKeywordRegion(previousAwaitIsKeyword);
 
         // We search for an Async expression (a function declaration or an async lambda expression)
         if (isAsyncExpr && !m_pscan->FHadNewLine())
@@ -4983,9 +4983,9 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho
 
     // switch scanner to treat 'yield' as keyword in generator functions
     // or as an identifier in non-generator functions
-    bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());
+    bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());
 
-    bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(fAsync);
+    bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(fAsync);
 
     if (pnodeFnc && pnodeFnc->sxFnc.IsGenerator())
     {
@@ -5491,8 +5491,8 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho
         m_grfscr |= uDeferSave;
     }
 
-    m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);
-    m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);
+    m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);
+    m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);
 
     // Restore the current function.
     if (buildAST)
@@ -6069,9 +6069,9 @@ bool Parser::ParseFncNames(ParseNodePtr pnodeFnc, ParseNodePtr pnodeFncParent, u
     {
         if (!fDeclaration)
         {
-            bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(!fDeclaration);
+            bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(!fDeclaration);
             m_pscan->Scan();
-            m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);
+            m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);
         }
         else
         {
@@ -6212,8 +6212,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,
 
     if (fLambda)
     {
-        fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsGenerator());
-        fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(fAsync || (pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsAsync()));
+        fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsGenerator());
+        fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(fAsync || (pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsAsync()));
     }
 
     Assert(!fNoArg || !fOneArg); // fNoArg and fOneArg can never be true at the same time.
@@ -6243,8 +6243,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,
 
         if (fLambda)
         {
-            m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);
-            m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);
+            m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);
+            m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);
         }
 
         return;
@@ -6494,8 +6494,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,
 
     if (fLambda)
     {
-        m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);
-        m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);
+        m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);
+        m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);
     }
 }
 
@@ -6826,9 +6826,9 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)
 
     // switch scanner to treat 'yield' as keyword in generator functions
     // or as an identifier in non-generator functions
-    bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());
+    bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());
 
-    bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsAsync());
+    bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsAsync());
 
     // Skip the arg list.
     m_pscan->ScanNoKeywords();
@@ -6923,8 +6923,8 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)
     Assert(tempNextFunctionId == pnodeFnc->sxFnc.deferredParseNextFunctionId);
     this->m_nextFunctionId = nextFunctionIdSave;
 
-    m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);
-    m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);
+    m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);
+    m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);
 }
 
 void Parser::FinishFncDecl(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, ParseNodePtr *lastNodeRef, bool skipCurlyBraces)
@@ -8115,10 +8115,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
 
         if (nop == knopYield)
         {
-            if (!m_pscan->YieldIsKeyword() || oplMin > opl)
+            if (!m_pscan->YieldIsKeywordRegion() || oplMin > opl)
             {
                 // The case where 'yield' is scanned as a keyword (tkYIELD) but the scanner
-                // is not treating yield as a keyword (!m_pscan->YieldIsKeyword()) occurs
+                // is not treating yield as a keyword (!m_pscan->YieldIsKeywordRegion()) occurs
                 // in strict mode non-generator function contexts.
                 //
                 // That is, 'yield' is a keyword because of strict mode, but YieldExpression
@@ -8135,7 +8135,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,
         }
         else if (nop == knopAwait)
         {
-            if (!m_pscan->AwaitIsKeyword() ||
+            if (!m_pscan->AwaitIsKeywordRegion() ||
                 m_currentScope->GetScopeType() == ScopeType_Parameter)
             {
                 // As with the 'yield' keyword, the case where 'await' is scanned as a keyword (tkAWAIT)
diff --git a/lib/Parser/Scan.cpp b/lib/Parser/Scan.cpp
@@ -104,8 +104,8 @@ Scanner<EncodingPolicy>::Scanner(Parser* parser, HashTbl *phtbl, Token *ptoken,
 
     this->es6UnicodeMode = scriptContext->GetConfig()->IsES6UnicodeExtensionsEnabled();
 
-    m_fYieldIsKeyword = false;
-    m_fAwaitIsKeyword = false;
+    m_fYieldIsKeywordRegion = false;
+    m_fAwaitIsKeywordRegion = false;
 }
 
 template <typename EncodingPolicy>
@@ -477,12 +477,12 @@ tokens Scanner<EncodingPolicy>::ScanIdentifierContinue(bool identifyKwds, bool f
             // So we can just assume it is an ID
             DebugOnly(int32 cch = UnescapeToTempBuf(pchMin, p));
             DebugOnly(tokens tk = m_phtbl->TkFromNameLen(m_tempChBuf.m_prgch, cch, IsStrictMode()));
-            Assert(tk == tkID || (tk == tkYIELD && !m_fYieldIsKeyword) || (tk == tkAWAIT && !m_fAwaitIsKeyword));
+            Assert(tk == tkID || (tk == tkYIELD && !this->YieldIsKeyword()) || (tk == tkAWAIT && !this->AwaitIsKeyword()));
             return tkID;
         }
         int32 cch = UnescapeToTempBuf(pchMin, p);
         tokens tk = m_phtbl->TkFromNameLen(m_tempChBuf.m_prgch, cch, IsStrictMode());
-        return (!m_fYieldIsKeyword && tk == tkYIELD) || (!m_fAwaitIsKeyword && tk == tkAWAIT) ? tkID : tk;
+        return (!this->YieldIsKeyword() && tk == tkYIELD) || (!this->AwaitIsKeyword() && tk == tkAWAIT) ? tkID : tk;
     }
 
     // UTF16 Scanner are only for syntax coloring, so it shouldn't come here.
@@ -494,7 +494,7 @@ tokens Scanner<EncodingPolicy>::ScanIdentifierContinue(bool identifyKwds, bool f
         // So we can just assume it is an ID
         DebugOnly(int32 cch = UnescapeToTempBuf(pchMin, p));
         DebugOnly(tokens tk = m_phtbl->TkFromNameLen(m_tempChBuf.m_prgch, cch, IsStrictMode()));
-        Assert(tk == tkID || (tk == tkYIELD && !m_fYieldIsKeyword) || (tk == tkAWAIT && !m_fAwaitIsKeyword));
+        Assert(tk == tkID || (tk == tkYIELD && !this->YieldIsKeyword()) || (tk == tkAWAIT && !this->AwaitIsKeyword()));
 
         m_ptoken->SetIdentifier(reinterpret_cast<const char *>(pchMin), (int32)(p - pchMin));
         return tkID;
@@ -506,16 +506,16 @@ tokens Scanner<EncodingPolicy>::ScanIdentifierContinue(bool identifyKwds, bool f
     if (!fHasEscape)
     {
         // If it doesn't have escape, then Scan() should have taken care of keywords (except
-        // yield if m_fYieldIsKeyword is false, in which case yield is treated as an identifier, and except
-        // await if m_fAwaitIsKeyword is false, in which case await is treated as an identifier).
+        // yield if this->YieldIsKeyword() is false, in which case yield is treated as an identifier, and except
+        // await if this->AwaitIsKeyword() is false, in which case await is treated as an identifier).
         // We don't have to check if the name is reserved word and return it as an Identifier
         Assert(pid->Tk(IsStrictMode()) == tkID
-            || (pid->Tk(IsStrictMode()) == tkYIELD && !m_fYieldIsKeyword)
-            || (pid->Tk(IsStrictMode()) == tkAWAIT && !m_fAwaitIsKeyword));
+            || (pid->Tk(IsStrictMode()) == tkYIELD && !this->YieldIsKeyword())
+            || (pid->Tk(IsStrictMode()) == tkAWAIT && !this->AwaitIsKeyword()));
         return tkID;
     }
     tokens tk = pid->Tk(IsStrictMode());
-    return tk == tkID || (tk == tkYIELD && !m_fYieldIsKeyword) || (tk == tkAWAIT && !m_fAwaitIsKeyword) ? tkID : tkNone;
+    return tk == tkID || (tk == tkYIELD && !this->YieldIsKeyword()) || (tk == tkAWAIT && !this->AwaitIsKeyword()) ? tkID : tkNone;
 }
 
 template <typename EncodingPolicy>
diff --git a/lib/Parser/Scan.h b/lib/Parser/Scan.h
@@ -388,26 +388,35 @@ class Scanner : public IScanner, public EncodingPolicy
     ScanState GetScanState() { return m_scanState; }
     void SetScanState(ScanState state) { m_scanState = state; }
 
-    bool SetYieldIsKeyword(bool fYieldIsKeyword)
+    bool SetYieldIsKeywordRegion(bool fYieldIsKeywordRegion)
     {
-        bool fPrevYieldIsKeyword = m_fYieldIsKeyword;
-        m_fYieldIsKeyword = fYieldIsKeyword;
-        return fPrevYieldIsKeyword;
+        bool fPrevYieldIsKeywordRegion = m_fYieldIsKeywordRegion;
+        m_fYieldIsKeywordRegion = fYieldIsKeywordRegion;
+        return fPrevYieldIsKeywordRegion;
+    }
+    bool YieldIsKeywordRegion()
+    {
+        return m_fYieldIsKeywordRegion;
     }
     bool YieldIsKeyword()
     {
-        return m_fYieldIsKeyword;
+        return YieldIsKeywordRegion() || this->IsStrictMode();
     }
 
-    bool SetAwaitIsKeyword(bool fAwaitIsKeyword)
+    bool SetAwaitIsKeywordRegion(bool fAwaitIsKeywordRegion)
     {
-        bool fPrevAwaitIsKeyword = m_fAwaitIsKeyword;
-        m_fAwaitIsKeyword = fAwaitIsKeyword;
-        return fPrevAwaitIsKeyword;
+        bool fPrevAwaitIsKeywordRegion = m_fAwaitIsKeywordRegion;
+        m_fAwaitIsKeywordRegion = fAwaitIsKeywordRegion;
+        return fPrevAwaitIsKeywordRegion;
     }
+    bool AwaitIsKeywordRegion()
+    {
+        return m_fAwaitIsKeywordRegion;
+    }
+
     bool AwaitIsKeyword()
     {
-        return m_fAwaitIsKeyword;
+        return AwaitIsKeywordRegion() || this->m_fIsModuleCode;
     }
 
     tokens TryRescanRegExp();
@@ -684,8 +693,8 @@ class Scanner : public IScanner, public EncodingPolicy
     BYTE m_DeferredParseFlags:2;            // suppressStrPid and suppressIdPid
     charcount_t m_ichCheck;             // character at which completion is to be computed.
     bool es6UnicodeMode;                // True if ES6Unicode Extensions are enabled.
-    bool m_fYieldIsKeyword;             // Whether to treat 'yield' as an identifier or keyword
-    bool m_fAwaitIsKeyword;             // Whether to treat 'await' as an identifier or keyword
+    bool m_fYieldIsKeywordRegion;       // Whether to treat 'yield' as an identifier or keyword
+    bool m_fAwaitIsKeywordRegion;       // Whether to treat 'await' as an identifier or keyword
 
     // Temporary buffer.
     TemporaryBuffer m_tempChBuf;
diff --git a/lib/Parser/kwd-swtch.h b/lib/Parser/kwd-swtch.h
@@ -13,7 +13,7 @@
             case 'w':
                 if (p[1] == 'a' && p[2] == 'i' && p[3] == 't' && !IsIdContinueNext(p+4, last)) {
                     p += 4;
-                    if (this->m_fAwaitIsKeyword || this->m_fIsModuleCode) {
+                    if (this->AwaitIsKeyword()) {
                         token = tkAWAIT;
                         goto LReserved;
                     }
@@ -438,7 +438,7 @@
         {
             if (p[0] == 'i' && p[1] == 'e' && p[2] == 'l' && p[3] == 'd' && !IsIdContinueNext(p+4, last)) {
                 p += 4;
-                if (this->m_fYieldIsKeyword || !this->m_parser || this->m_parser->IsStrictMode()) {
+                if (this->YieldIsKeyword()) {
                     token = tkYIELD;
                     goto LReserved;
                 }
diff --git a/test/es6/await-futreserved-only-in-modules.js b/test/es6/await-futreserved-only-in-modules.js
@@ -24,12 +24,15 @@ function f() {
 }
 f();
 
-var m = '';
-try {
-    WScript.LoadModule('var await = 0;', 'samethread');
-} catch (e) {
-    m = e.message;
+function test(awaitStr)
+{
+    try {
+        WScript.LoadModule('var ' + awaitStr + ' = 0;', 'samethread');
+    } catch (e) {
+        return e.message === 'The use of a keyword for an identifier is invalid';
+    }
+    print("Failed: no syntax error of identifier '" + awaitStr + "'");
+    return false;
 }
 
-print(m === 'The use of a keyword for an identifier is invalid' ?
-        'pass' : 'fail');
+print(test("await") & test("\\u0061wait")? 'pass' : '');
diff --git a/test/strict/23.reservedWords.baseline b/test/strict/23.reservedWords.baseline
diff --git a/test/strict/23.reservedWords.js b/test/strict/23.reservedWords.js
diff --git a/test/strict/23.reservedWords_sm.baseline b/test/strict/23.reservedWords_sm.baseline

Original file line number	Diff line number	Diff line change
`@@ -256,8 +256,8 @@ HRESULT Parser::ValidateSyntax(LPCUTF8 pszSrc, size_t encodedCharCount, bool isG`
`256`	`256`
`257`	`257`	`// Give the scanner the source and get the first token`
`258`	`258`	`m_pscan->SetText(pszSrc, 0, encodedCharCount, 0, grfscr);`
`259`		`- m_pscan->SetYieldIsKeyword(isGenerator);`
`260`		`- m_pscan->SetAwaitIsKeyword(isAsync);`
	`259`	`+ m_pscan->SetYieldIsKeywordRegion(isGenerator);`
	`260`	`+ m_pscan->SetAwaitIsKeywordRegion(isAsync);`
`261`	`261`	`m_pscan->Scan();`
`262`	`262`
`263`	`263`	`uint nestedCount = 0;`
`@@ -2929,9 +2929,9 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,`
`2929`	`2929`	`isAsyncExpr = true;`
`2930`	`2930`	`}`
`2931`	`2931`
`2932`		`- bool previousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(isAsyncExpr);`
	`2932`	`+ bool previousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(isAsyncExpr);`
`2933`	`2933`	`m_pscan->Scan();`
`2934`		`- m_pscan->SetAwaitIsKeyword(previousAwaitIsKeyword);`
	`2934`	`+ m_pscan->SetAwaitIsKeywordRegion(previousAwaitIsKeyword);`
`2935`	`2935`
`2936`	`2936`	`// We search for an Async expression (a function declaration or an async lambda expression)`
`2937`	`2937`	`if (isAsyncExpr && !m_pscan->FHadNewLine())`
`@@ -4983,9 +4983,9 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho`
`4983`	`4983`
`4984`	`4984`	`// switch scanner to treat 'yield' as keyword in generator functions`
`4985`	`4985`	`// or as an identifier in non-generator functions`
`4986`		`- bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());`
	`4986`	`+ bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());`
`4987`	`4987`
`4988`		`- bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(fAsync);`
	`4988`	`+ bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(fAsync);`
`4989`	`4989`
`4990`	`4990`	`if (pnodeFnc && pnodeFnc->sxFnc.IsGenerator())`
`4991`	`4991`	`{`
`@@ -5491,8 +5491,8 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho`
`5491`	`5491`	`m_grfscr \|= uDeferSave;`
`5492`	`5492`	`}`
`5493`	`5493`
`5494`		`- m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);`
`5495`		`- m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);`
	`5494`	`+ m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);`
	`5495`	`+ m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);`
`5496`	`5496`
`5497`	`5497`	`// Restore the current function.`
`5498`	`5498`	`if (buildAST)`
`@@ -6069,9 +6069,9 @@ bool Parser::ParseFncNames(ParseNodePtr pnodeFnc, ParseNodePtr pnodeFncParent, u`
`6069`	`6069`	`{`
`6070`	`6070`	`if (!fDeclaration)`
`6071`	`6071`	`{`
`6072`		`- bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(!fDeclaration);`
	`6072`	`+ bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(!fDeclaration);`
`6073`	`6073`	`m_pscan->Scan();`
`6074`		`- m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);`
	`6074`	`+ m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);`
`6075`	`6075`	`}`
`6076`	`6076`	`else`
`6077`	`6077`	`{`
`@@ -6212,8 +6212,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,`
`6212`	`6212`
`6213`	`6213`	`if (fLambda)`
`6214`	`6214`	`{`
`6215`		`- fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsGenerator());`
`6216`		`- fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(fAsync \|\| (pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsAsync()));`
	`6215`	`+ fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsGenerator());`
	`6216`	`+ fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(fAsync \|\| (pnodeParentFnc != nullptr && pnodeParentFnc->sxFnc.IsAsync()));`
`6217`	`6217`	`}`
`6218`	`6218`
`6219`	`6219`	`Assert(!fNoArg \|\| !fOneArg); // fNoArg and fOneArg can never be true at the same time.`
`@@ -6243,8 +6243,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,`
`6243`	`6243`
`6244`	`6244`	`if (fLambda)`
`6245`	`6245`	`{`
`6246`		`- m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);`
`6247`		`- m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);`
	`6246`	`+ m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);`
	`6247`	`+ m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);`
`6248`	`6248`	`}`
`6249`	`6249`
`6250`	`6250`	`return;`
`@@ -6494,8 +6494,8 @@ void Parser::ParseFncFormals(ParseNodePtr pnodeFnc, ParseNodePtr pnodeParentFnc,`
`6494`	`6494`
`6495`	`6495`	`if (fLambda)`
`6496`	`6496`	`{`
`6497`		`- m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);`
`6498`		`- m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);`
	`6497`	`+ m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);`
	`6498`	`+ m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);`
`6499`	`6499`	`}`
`6500`	`6500`	`}`
`6501`	`6501`
`@@ -6826,9 +6826,9 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)`
`6826`	`6826`
`6827`	`6827`	`// switch scanner to treat 'yield' as keyword in generator functions`
`6828`	`6828`	`// or as an identifier in non-generator functions`
`6829`		`- bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());`
	`6829`	`+ bool fPreviousYieldIsKeyword = m_pscan->SetYieldIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());`
`6830`	`6830`
`6831`		`- bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeyword(pnodeFnc && pnodeFnc->sxFnc.IsAsync());`
	`6831`	`+ bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsAsync());`
`6832`	`6832`
`6833`	`6833`	`// Skip the arg list.`
`6834`	`6834`	`m_pscan->ScanNoKeywords();`
`@@ -6923,8 +6923,8 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)`
`6923`	`6923`	`Assert(tempNextFunctionId == pnodeFnc->sxFnc.deferredParseNextFunctionId);`
`6924`	`6924`	`this->m_nextFunctionId = nextFunctionIdSave;`
`6925`	`6925`
`6926`		`- m_pscan->SetYieldIsKeyword(fPreviousYieldIsKeyword);`
`6927`		`- m_pscan->SetAwaitIsKeyword(fPreviousAwaitIsKeyword);`
	`6926`	`+ m_pscan->SetYieldIsKeywordRegion(fPreviousYieldIsKeyword);`
	`6927`	`+ m_pscan->SetAwaitIsKeywordRegion(fPreviousAwaitIsKeyword);`
`6928`	`6928`	`}`
`6929`	`6929`
`6930`	`6930`	`void Parser::FinishFncDecl(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, ParseNodePtr *lastNodeRef, bool skipCurlyBraces)`
`@@ -8115,10 +8115,10 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8115`	`8115`
`8116`	`8116`	`if (nop == knopYield)`
`8117`	`8117`	`{`
`8118`		`- if (!m_pscan->YieldIsKeyword() \|\| oplMin > opl)`
	`8118`	`+ if (!m_pscan->YieldIsKeywordRegion() \|\| oplMin > opl)`
`8119`	`8119`	`{`
`8120`	`8120`	`// The case where 'yield' is scanned as a keyword (tkYIELD) but the scanner`
`8121`		`- // is not treating yield as a keyword (!m_pscan->YieldIsKeyword()) occurs`
	`8121`	`+ // is not treating yield as a keyword (!m_pscan->YieldIsKeywordRegion()) occurs`
`8122`	`8122`	`// in strict mode non-generator function contexts.`
`8123`	`8123`	`//`
`8124`	`8124`	`// That is, 'yield' is a keyword because of strict mode, but YieldExpression`
`@@ -8135,7 +8135,7 @@ ParseNodePtr Parser::ParseExpr(int oplMin,`
`8135`	`8135`	`}`
`8136`	`8136`	`else if (nop == knopAwait)`
`8137`	`8137`	`{`
`8138`		`- if (!m_pscan->AwaitIsKeyword() \|\|`
	`8138`	`+ if (!m_pscan->AwaitIsKeywordRegion() \|\|`
`8139`	`8139`	`m_currentScope->GetScopeType() == ScopeType_Parameter)`
`8140`	`8140`	`{`
`8141`	`8141`	`// As with the 'yield' keyword, the case where 'await' is scanned as a keyword (tkAWAIT)`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`case 'w':`
`14`	`14`	`if (p[1] == 'a' && p[2] == 'i' && p[3] == 't' && !IsIdContinueNext(p+4, last)) {`
`15`	`15`	`p += 4;`
`16`		`- if (this->m_fAwaitIsKeyword \|\| this->m_fIsModuleCode) {`
	`16`	`+ if (this->AwaitIsKeyword()) {`
`17`	`17`	`token = tkAWAIT;`
`18`	`18`	`goto LReserved;`
`19`	`19`	`}`
`@@ -438,7 +438,7 @@`
`438`	`438`	`{`
`439`	`439`	`if (p[0] == 'i' && p[1] == 'e' && p[2] == 'l' && p[3] == 'd' && !IsIdContinueNext(p+4, last)) {`
`440`	`440`	`p += 4;`
`441`		`- if (this->m_fYieldIsKeyword \|\| !this->m_parser \|\| this->m_parser->IsStrictMode()) {`
	`441`	`+ if (this->YieldIsKeyword()) {`
`442`	`442`	`token = tkYIELD;`
`443`	`443`	`goto LReserved;`
`444`	`444`	`}`