[1.7>master] [MERGE chakra-core#4136 @boingoing] Support for defer parse of object literal methods

boingoing · boingoing · commit 76620d332fa2 · 2017-11-03T18:16:48.000-07:00
Merge pull request chakra-core#4136 from boingoing:DeferParseMethods This is mostly a straightforward modification to the defer-parse methods in the parser to enable them to know how to handle the object literal method grammar. Communicate the fact that the deferred function is a method via a parser flag - `fscrDeferredFncIsMethod`.
diff --git a/lib/Parser/Parse.cpp b/lib/Parser/Parse.cpp
@@ -3204,6 +3204,14 @@ ParseNodePtr Parser::ParseTerm(BOOL fAllowCall,
         pid = ParseSuper<buildAST>(!!fAllowCall);
         isSpecialName = true;
 
+        // Super reference and super call need to push a pid ref to 'this' even when not building an AST
+        ReferenceSpecialName(wellKnownPropertyPids._this, ichMin, ichLim);
+        // Super call needs to reference 'new.target'
+        if (pid == wellKnownPropertyPids._superConstructor)
+        {
+            ReferenceSpecialName(wellKnownPropertyPids._newTarget, ichMin, ichLim);
+        }
+
         goto LIdentifier;
 
     case tkTHIS:
@@ -4531,6 +4539,11 @@ ParseNodePtr Parser::ParseMemberList(LPCOLESTR pNameHint, uint32* pNameHintLengt
             {
                 Error(ERRsyntax);
             }
+
+            // Include star character in the function extents
+            ichMin = m_pscan->IchMinTok();
+            iecpMin = m_pscan->IecpMinTok();
+
             m_pscan->ScanForcingPid();
             fncDeclFlags |= fFncGenerator;
         }
@@ -4704,7 +4717,7 @@ ParseNodePtr Parser::ParseMemberList(LPCOLESTR pNameHint, uint32* pNameHintLengt
             ParseNodePtr pnodeFunc = ParseFncDecl<buildAST>(fncDeclFlags | (isAsyncMethod ? fFncAsync : fFncNoFlgs), pFullNameHint,
                 /*needsPIDOnRCurlyScan*/ false, /*resetParsingSuperRestrictionState*/ false);
 
-            if (isAsyncMethod)
+            if (isAsyncMethod || isGenerator)
             {
                 pnodeFunc->sxFnc.cbMin = iecpMin;
                 pnodeFunc->ichMin = ichMin;
@@ -5277,7 +5290,6 @@ 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->SetYieldIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsGenerator());
-
     bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(fAsync);
 
     if (pnodeFnc && pnodeFnc->sxFnc.IsGenerator())
@@ -5318,10 +5330,10 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho
     }
 
     uint uDeferSave = m_grfscr & fscrDeferFncParse;
-    if (flags & fFncNoName)
+    if (flags & fFncClassMember)
     {
-        // Disable deferral on getter/setter or other construct with unusual text bounds
-        // (fFncNoName) as these are usually trivial, and re-parsing is problematic.
+        // Disable deferral on class members or other construct with unusual text bounds
+        // as these are usually trivial, and re-parsing is problematic.
         // NOTE: It is probably worth supporting these cases for memory and load-time purposes,
         // especially as they become more and more common.
         m_grfscr &= ~fscrDeferFncParse;
@@ -7170,6 +7182,7 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)
     m_pnestedCount = &pnodeFnc->sxFnc.nestedCount;
 
     bool fLambda = pnodeFnc->sxFnc.IsLambda();
+    bool fMethod = pnodeFnc->sxFnc.IsMethod();
 
     // Cue up the parser to the start of the function body.
     if (pnodeFnc->sxFnc.pnodeName)
@@ -7180,7 +7193,30 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)
     else
     {
         m_pscan->SetCurrentCharacter(pnodeFnc->ichMin, pnodeFnc->sxFnc.lineNumber);
-        if (pnodeFnc->sxFnc.IsAccessor())
+        
+        if (fMethod)
+        {
+            // Method. Skip identifier name, computed property name, "async", "get", "set", and '*' or '(' characters.
+            for (;;)
+            {
+                m_pscan->Scan();
+                // '[' character indicates a computed property name for this method. We should consume it.
+                if (m_token.tk == tkLBrack)
+                {
+                    // We don't care what the name expr is.
+                    m_pscan->Scan();
+                    ParseExpr<false>();
+                    Assert(m_token.tk == tkRBrack);
+                    continue;
+                }
+                // Quit scanning ahead when we reach a '(' character which opens the arg list.
+                if (m_token.tk == tkLParen)
+                {
+                    break;
+                }
+            }
+        }
+        else if (pnodeFnc->sxFnc.IsAccessor())
         {
             // Getter/setter. The node text starts with the name, so eat that.
             m_pscan->ScanNoKeywords();
@@ -7212,7 +7248,11 @@ void Parser::FinishFncNode(ParseNodePtr pnodeFnc)
     bool fPreviousAwaitIsKeyword = m_pscan->SetAwaitIsKeywordRegion(pnodeFnc && pnodeFnc->sxFnc.IsAsync());
 
     // Skip the arg list.
-    m_pscan->Scan();
+    if (!fMethod)
+    {
+        // If this is a method, we've already advanced to the '(' token.
+        m_pscan->Scan();
+    }
     if (m_token.tk == tkStar)
     {
         Assert(pnodeFnc->sxFnc.IsGenerator());
@@ -11576,7 +11616,9 @@ ParseNodePtr Parser::Parse(LPCUTF8 pszSrc, size_t offset, size_t length, charcou
             ushort flags = fFncNoFlgs;
             size_t iecpMin = 0;
             charcount_t ichMin = 0;
-            bool isAsyncMethod = false;
+            bool isAsync = false;
+            bool isGenerator = false;
+            bool isMethod = false;
 
             // The top-level deferred function body was defined by a function expression whose parsing was deferred. We are now
             // parsing it, so unset the flag so that any nested functions are parsed normally. This flag is only applicable the
@@ -11595,49 +11637,73 @@ ParseNodePtr Parser::Parse(LPCUTF8 pszSrc, size_t offset, size_t length, charcou
                 flags |= fFncDeclaration;
             }
 
-            // There are three cases which can confirm async function:
-            //   async function...   -> async function
-            //   async (...          -> async lambda with parens around the formal parameter
-            //   async identifier... -> async lambda with single identifier parameter
+            if (m_grfscr & fscrDeferredFncIsMethod)
+            {
+                m_grfscr &= ~fscrDeferredFncIsMethod;
+                isMethod = true;
+                flags |= fFncNoName | fFncMethod;
+            }
+
+            // These are the cases which can confirm async function:
+            //   async function() {}         -> async function
+            //   async () => {}              -> async lambda with parens around the formal parameter
+            //   async arg => {}             -> async lambda with single identifier parameter
+            //   async name() {}             -> async method
+            //   async [computed_name]() {}  -> async method with a computed name
             if (m_token.tk == tkID && m_token.GetIdentifier(m_phtbl) == wellKnownPropertyPids.async && m_scriptContext->GetConfig()->IsES7AsyncAndAwaitEnabled())
             {
                 ichMin = m_pscan->IchMinTok();
                 iecpMin = m_pscan->IecpMinTok();
 
-                // Keep state so we can rewind if it turns out that this isn't an async function.
-                // The only way this can happen is if we have a lambda with a single formal parameter named 'async' not enclosed by parens.
+                // Keep state so we can rewind if it turns out that this isn't an async function:
+                //   async() {}              -> method named async
+                //   async => {}             -> lambda with single parameter named async
                 RestorePoint termStart;
                 m_pscan->Capture(&termStart);
 
                 m_pscan->Scan();
-                if ((m_token.tk == tkID || m_token.tk == tkLParen || m_token.tk == tkFUNCTION) && !m_pscan->FHadNewLine())
+
+                if (m_token.tk == tkDArrow || (m_token.tk == tkLParen && isMethod) || m_pscan->FHadNewLine())
                 {
-                    flags |= fFncAsync;
-                    isAsyncMethod = true;
+                    m_pscan->SeekTo(termStart);
                 }
                 else
                 {
-                    m_pscan->SeekTo(termStart);
+                    flags |= fFncAsync;
+                    isAsync = true;
                 }
             }
 
-            // If first token of the function is tkID or tkLParen, this is a lambda.
-            if (m_token.tk == tkID || m_token.tk == tkLParen)
+            if (m_token.tk == tkStar && m_scriptContext->GetConfig()->IsES6GeneratorsEnabled())
             {
-                flags |= fFncLambda;
+                ichMin = m_pscan->IchMinTok();
+                iecpMin = m_pscan->IecpMinTok();
+
+                flags |= fFncGenerator;
+                isGenerator = true;
+
+                m_pscan->Scan();
             }
-            else
+
+            // Eat the computed name expression
+            if (m_token.tk == tkLBrack && isMethod)
+            {
+                m_pscan->Scan();
+                ParseExpr<false>();
+            }
+
+            if (!isMethod && (m_token.tk == tkID || m_token.tk == tkLParen))
             {
-                // Must be ordinary function keyword - do not eat the token
-                ChkCurTokNoScan(tkFUNCTION, ERRsyntax);
+                // If first token of the function is tkID or tkLParen, this is a lambda.
+                flags |= fFncLambda;
             }
 
             ParseNodePtr pnodeFnc = ParseFncDecl<true>(flags, nullptr, false, false);
             pnodeProg->sxFnc.pnodeBody = nullptr;
             AddToNodeList(&pnodeProg->sxFnc.pnodeBody, &lastNodeRef, pnodeFnc);
 
-            // Include the async keyword in the function extents
-            if (isAsyncMethod)
+            // Include the async keyword or star character in the function extents
+            if (isAsync || isGenerator)
             {
                 pnodeFnc->sxFnc.cbMin = iecpMin;
                 pnodeFnc->ichMin = ichMin;
@@ -12578,6 +12644,16 @@ IdentPtr Parser::ParseSuper(bool fAllowCall)
         break;
     }
 
+    currentNodeFunc->sxFnc.SetHasSuperReference(TRUE);
+    CHAKRATEL_LANGSTATS_INC_LANGFEATURECOUNT(Super, m_scriptContext);
+
+    // If we are defer parsing, we can skip verifying that the super reference is valid.
+    // If it wasn't the parser would have thrown during upfront parsing and we wouldn't be defer parsing the function.
+    if (m_parseType == ParseType_Deferred)
+    {
+        return superPid;
+    }
+
     if (!fAllowCall && (m_token.tk == tkLParen))
     {
         Error(ERRInvalidSuper); // new super() is not allowed
@@ -12616,9 +12692,6 @@ IdentPtr Parser::ParseSuper(bool fAllowCall)
         Error(ERRInvalidSuper);
     }
     
-    currentNodeFunc->sxFnc.SetHasSuperReference(TRUE);
-    CHAKRATEL_LANGSTATS_INC_LANGFEATURECOUNT(Super, m_scriptContext);
-
     return superPid;
 }
 
diff --git a/lib/Parser/ParseFlags.h b/lib/Parser/ParseFlags.h
@@ -47,6 +47,7 @@ enum
                                      //  let/const in global scope instead of eval scope so that they can be preserved across console inputs
     fscrNoAsmJs = 1 << 25, // Disable generation of asm.js code
     fscrIsModuleCode = 1 << 26, // Current code should be parsed as a module body
-    fscrAll = (1 << 27) - 1
-};
 
+    fscrDeferredFncIsMethod = 1 << 27,
+    fscrAll = (1 << 28) - 1
+};
diff --git a/lib/Runtime/Base/FunctionBody.cpp b/lib/Runtime/Base/FunctionBody.cpp
@@ -1583,7 +1583,8 @@ namespace Js
       paramScopeSlotArraySize(0),
       m_reparsed(false),
       m_isAsmJsFunction(false),
-      m_tag21(true)
+      m_tag21(true),
+      m_isMethod(false)
 #if DBG
         ,m_wasEverAsmjsMode(false)
         ,scopeObjectSize(0)
@@ -1633,6 +1634,7 @@ namespace Js
       m_isStaticNameFunction(proxy->GetIsStaticNameFunction()),
       m_reportedInParamCount(proxy->GetReportedInParamsCount()),
       m_reparsed(proxy->IsReparsed()),
+      m_isMethod(proxy->IsMethod()),
       m_tag21(true)
 #if DBG
       , m_wasEverAsmjsMode(proxy->m_wasEverAsmjsMode)
@@ -2319,6 +2321,16 @@ namespace Js
                         // (not a function declaration statement).
                         grfscr |= fscrDeferredFncExpression;
                     }
+
+                    if (funcBody->IsMethod())
+                    {
+                        grfscr |= fscrDeferredFncIsMethod;
+                    }
+                    else
+                    {
+                        grfscr &= ~fscrDeferredFncIsMethod;
+                    }
+
                     if (!CONFIG_FLAG(DeferNested) || isDebugOrAsmJsReparse)
                     {
                         grfscr &= ~fscrDeferFncParse; // Disable deferred parsing if not DeferNested, or doing a debug/asm.js re-parse
diff --git a/lib/Runtime/Base/FunctionBody.h b/lib/Runtime/Base/FunctionBody.h
@@ -1843,6 +1843,8 @@ namespace Js
         LPCUTF8 GetStartOfDocument(const char16* reason = nullptr) const;
         bool IsReparsed() const { return m_reparsed; }
         void SetReparsed(bool set) { m_reparsed = set; }
+        bool IsMethod() const { return m_isMethod; }
+        void SetIsMethod(bool set) { m_isMethod = set; }
 #ifdef NTBUILD
         bool GetExternalDisplaySourceName(BSTR* sourceName);
 #endif
@@ -1979,12 +1981,11 @@ namespace Js
         FieldWithBarrier(bool) m_isEval : 1;              // Source code is in 'eval'
         FieldWithBarrier(bool) m_isDynamicFunction : 1;   // Source code is in 'Function'
         FieldWithBarrier(bool) m_hasImplicitArgIns : 1;
-        FieldWithBarrier(bool) m_dontInline : 1;            // Used by the JIT's inliner
-
-        // Indicates if the function has been reparsed for debug attach/detach scenario.
-        FieldWithBarrier(bool) m_reparsed : 1;
+        FieldWithBarrier(bool) m_dontInline : 1;          // Used by the JIT's inliner
+        FieldWithBarrier(bool) m_reparsed : 1;            // Indicates if the function has been reparsed for debug attach/detach scenario.
+        FieldWithBarrier(bool) m_isMethod : 1;            // Function is an object literal method
 #if DBG
-        FieldWithBarrier(bool) m_wasEverAsmjsMode : 1; // has m_isAsmjsMode ever been true
+        FieldWithBarrier(bool) m_wasEverAsmjsMode : 1;    // has m_isAsmjsMode ever been true
 #endif
 
         // This field is not required for deferred parsing but because our thunks can't handle offsets > 128 bytes
diff --git a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
@@ -1403,6 +1403,7 @@ FuncInfo * ByteCodeGenerator::StartBindFunction(const char16 *name, uint nameLen
         parseableFunctionInfo->deferredParseNextFunctionId = pnode->sxFnc.deferredParseNextFunctionId;
 #endif
         parseableFunctionInfo->SetIsDeclaration(pnode->sxFnc.IsDeclaration() != 0);
+        parseableFunctionInfo->SetIsMethod(pnode->sxFnc.IsMethod() != 0);
         parseableFunctionInfo->SetIsAccessor(pnode->sxFnc.IsAccessor() != 0);
         if (pnode->sxFnc.IsAccessor())
         {
diff --git a/test/es6/DeferParseMethods.js b/test/es6/DeferParseMethods.js
diff --git a/test/es6/rlexe.xml b/test/es6/rlexe.xml

Original file line number	Diff line number	Diff line change
`@@ -1403,6 +1403,7 @@ FuncInfo * ByteCodeGenerator::StartBindFunction(const char16 *name, uint nameLen`
`1403`	`1403`	`parseableFunctionInfo->deferredParseNextFunctionId = pnode->sxFnc.deferredParseNextFunctionId;`
`1404`	`1404`	`#endif`
`1405`	`1405`	`parseableFunctionInfo->SetIsDeclaration(pnode->sxFnc.IsDeclaration() != 0);`
	`1406`	`+ parseableFunctionInfo->SetIsMethod(pnode->sxFnc.IsMethod() != 0);`
`1406`	`1407`	`parseableFunctionInfo->SetIsAccessor(pnode->sxFnc.IsAccessor() != 0);`
`1407`	`1408`	`if (pnode->sxFnc.IsAccessor())`
`1408`	`1409`	`{`