[MERGE #2219 @pleath] Port fix for bad binding of async arrow functio…

…n parameters

Merge pull request #2219 from pleath:1612_1.3

Apply the same parse-time-binding logic to async arrow function parameter lists as to normal arrow function parameter lists. (They take different paths in the parser prior to the discovery of the arrow.)

lib/Parser/Parse.cpp

@@ -2868,22 +2868,24 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
         ichMin = m_pscan->IchMinTok();
         iecpMin  = m_pscan->IecpMinTok();
 
+        if (pid == wellKnownPropertyPids.async &&
+            m_scriptContext->GetConfig()->IsES7AsyncAndAwaitEnabled())
+        {
+            isAsyncExpr = true;
+        }
+
         m_pscan->Scan();
 
         // We search for an Async expression (a function declaration or an async lambda expression)
-        if (pid == wellKnownPropertyPids.async &&
-            !m_pscan->FHadNewLine() &&
-            m_scriptContext->GetConfig()->IsES7AsyncAndAwaitEnabled())
+        if (isAsyncExpr && !m_pscan->FHadNewLine())
         {
             if (m_token.tk == tkFUNCTION)
             {
-                isAsyncExpr = true;
                 goto LFunction;
             }
             else if (m_token.tk == tkID)
             {
                 isLambdaExpr = true;
-                isAsyncExpr = true;
                 goto LFunction;
             }
         }
@@ -3234,7 +3236,7 @@ LFunction :
         break;
     }
 
-    pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, &fCanAssign, &term, pfIsDotOrIndex);
+    pnode = ParsePostfixOperators<buildAST>(pnode, fAllowCall, fInNew, isAsyncExpr, &fCanAssign, &term, pfIsDotOrIndex);
 
     // Pass back identifier if requested
     if (pToken && term.tk == tkID)
@@ -3329,6 +3331,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
     ParseNodePtr pnode,
     BOOL fAllowCall,
     BOOL fInNew,
+    BOOL isAsyncExpr,
     BOOL *pfCanAssign,
     _Inout_ IdentToken* pToken,
     _Out_opt_ bool* pfIsDotOrIndex /*= nullptr */)
@@ -3368,6 +3371,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
                         pToken->tk = tkNone; // This is no longer an identifier
                     }
                     fInNew = FALSE;
+                    ChkCurTok(tkRParen, ERRnoRparen);
                 }
                 else
                 {
@@ -3377,6 +3381,17 @@ ParseNodePtr Parser::ParsePostfixOperators(
                         return pnode;
                     }
 
+                    uint saveNextBlockId = m_nextBlockId;
+                    uint saveCurrBlockId = GetCurrentBlock()->sxBlock.blockId;
+
+                    if (isAsyncExpr)
+                    {
+                        // Advance the block ID here in case this parenthetical expression turns out to be a lambda parameter list.
+                        // That way the pid ref stacks will be created in their correct final form, and we can simply fix
+                        // up function ID's.
+                        GetCurrentBlock()->sxBlock.blockId = m_nextBlockId++;
+                    }
+
                     ParseNodePtr pnodeArgs = ParseArgList<buildAST>(&callOfConstants, &spreadArgCount, &count);
                     // We used to un-defer a deferred function body here if it was called as part of the expression that declared it.
                     // We now detect this case up front in ParseFncDecl, which is cheaper and simpler.
@@ -3411,8 +3426,20 @@ ParseNodePtr Parser::ParsePostfixOperators(
                         }
                         pToken->tk = tkNone; // This is no longer an identifier
                     }
+
+                    ChkCurTok(tkRParen, ERRnoRparen);
+
+                    if (isAsyncExpr)
+                    {
+                        GetCurrentBlock()->sxBlock.blockId = saveCurrBlockId;
+                        if (m_token.tk == tkDArrow)
+                        {
+                            // We're going to rewind and reinterpret the expression as a parameter list.
+                            // Put back the original next-block-ID so the existing pid ref stacks will be correct.
+                            m_nextBlockId = saveNextBlockId;
+                        }
+                    }
                 }
-                ChkCurTok(tkRParen, ERRnoRparen);
                 if (pfCanAssign)
                 {
                     *pfCanAssign = FALSE;
@@ -12183,7 +12210,7 @@ ParseNodePtr Parser::ParseDestructuredVarDecl(tokens declarationType, bool isDec
             BOOL fCanAssign;
             IdentToken token;
             // Look for postfix operator
-            pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, &fCanAssign, &token);
+            pnodeElem = ParsePostfixOperators<buildAST>(pnodeElem, TRUE, FALSE, FALSE, &fCanAssign, &token);
         }
     }
     else if (m_token.tk == tkSUPER || m_token.tk == tkID)

lib/Parser/Parse.h

@@ -835,6 +835,7 @@ class Parser
         ParseNodePtr pnode,
         BOOL fAllowCall, 
         BOOL fInNew, 
+        BOOL isAsyncExpr,
         BOOL *pfCanAssign, 
         _Inout_ IdentToken* pToken, 
         _Out_opt_ bool* pfIsDotOrIndex = nullptr);

test/es6/lambda-params-shadow.js

@@ -13,6 +13,8 @@ class B extends A {
         super();
         ((B) => { super.increment() })();
         (A=> { super.increment() })();
+        let C = async (B) => { B };
+        let D = async A => { A };
     }
 }
 let b = new B();

test/es6/rlexe.xml

@@ -15,13 +15,13 @@
   <test>
     <default>
       <files>lambda-params-shadow.js</files>
-      <compile-flags>-off:deferparse -args summary -endargs</compile-flags>
+      <compile-flags>-off:deferparse -es7asyncawait</compile-flags>
     </default>
   </test>
   <test>
     <default>
       <files>lambda-params-shadow.js</files>
-      <compile-flags>-force:deferparse -args summary -endargs</compile-flags>
+      <compile-flags>-force:deferparse -es7asyncawait</compile-flags>
     </default>
   </test>
   <test>