//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#include "ParserPch.h"

#include "FormalsUtil.h"

#include "../Runtime/Language/SourceDynamicProfileManager.h"

#include "ByteCode/ByteCodeSerializer.h"

#if DBG_DUMP

void PrintPnodeWIndent(ParseNode *pnode, int indentAmt);

#endif

const char* const nopNames[knopLim] = {

#define PTNODE(nop,sn,pc,nk,grfnop,json) sn,

#include "ptlist.h"

};

void printNop(int nop) {

Output::Print(_u("%S\n"), nopNames[nop]);

}

const uint ParseNode::mpnopgrfnop[knopLim] =

{

#define PTNODE(nop,sn,pc,nk,grfnop,json) grfnop,

#include "ptlist.h"

};

bool Parser::IsES6DestructuringEnabled() const

{

return m_scriptContext->GetConfig()->IsES6DestructuringEnabled();

}

struct BlockInfoStack

{

StmtNest pstmt;

ParseNodeBlock *pnodeBlock;

ParseNodePtr *m_ppnodeLex; // lexical variable list tail

BlockInfoStack *pBlockInfoOuter; // containing block's BlockInfoStack

BlockInfoStack *pBlockInfoFunction; // nearest function's BlockInfoStack (if pnodeBlock is a function, this points to itself)

};

#if DEBUG

Parser::Parser(Js::ScriptContext* scriptContext, BOOL strictMode, PageAllocator *alloc, bool isBackground, size_t size)

#else

Parser::Parser(Js::ScriptContext* scriptContext, BOOL strictMode, PageAllocator *alloc, bool isBackground)

#endif

: m_nodeAllocator(_u("Parser"), alloc ? alloc : scriptContext->GetThreadContext()->GetPageAllocator(), Parser::OutOfMemory),

m_cactIdentToNodeLookup(0),

m_grfscr(fscrNil),

m_length(0),

m_originalLength(0),

m_nextFunctionId(nullptr),

m_sourceContextInfo(nullptr),

#if ENABLE_BACKGROUND_PARSING

m_isInBackground(isBackground),

m_hasParallelJob(false),

m_doingFastScan(false),

#endif

m_nextBlockId(0),

m_tempGuestArenaReleased(false),

m_tempGuestArena(scriptContext->GetTemporaryGuestAllocator(_u("ParserRegex")), scriptContext->GetRecycler()),

// use the GuestArena directly for keeping the RegexPattern* alive during byte code generation

m_registeredRegexPatterns(m_tempGuestArena->GetAllocator()),

m_scriptContext(scriptContext),

m_token(), // should initialize to 0/nullptrs

m_scan(this, &m_token, scriptContext),

m_currentNodeNonLambdaFunc(nullptr),

m_currentNodeNonLambdaDeferredFunc(nullptr),

m_currentNodeFunc(nullptr),

m_currentNodeDeferredFunc(nullptr),

m_currentNodeProg(nullptr),

m_currDeferredStub(nullptr),

m_currDeferredStubCount(0),

m_pCurrentAstSize(nullptr),

m_ppnodeScope(nullptr),

m_ppnodeExprScope(nullptr),

m_ppnodeVar(nullptr),

m_inDeferredNestedFunc(false),

m_reparsingLambdaParams(false),

m_disallowImportExportStmt(false),

m_isInParsingArgList(false),

m_hasDestructuringPattern(false),

m_hasDeferredShorthandInitError(false),

m_deferCommaError(false),

m_pnestedCount(nullptr),

wellKnownPropertyPids(), // should initialize to nullptrs

m_sourceLim(0),

m_functionBody(nullptr),

m_parseType(ParseType_Upfront),

m_arrayDepth(0),

m_funcInArrayDepth(0),

m_funcInArray(0),

m_scopeCountNoAst(0),

m_funcParenExprDepth(0),

m_deferEllipsisError(false),

m_deferEllipsisErrorLoc(), // calls default initializer

m_deferCommaErrorLoc(),

m_tryCatchOrFinallyDepth(0),

m_pstmtCur(nullptr),

m_currentBlockInfo(nullptr),

m_currentScope(nullptr),

currBackgroundParseItem(nullptr),

backgroundParseItems(nullptr),

fastScannedRegExpNodes(nullptr),

m_currentDynamicBlock(nullptr),

m_UsesArgumentsAtGlobal(false),

m_fUseStrictMode(strictMode),

m_InAsmMode(false),

m_deferAsmJs(true),

m_fExpectExternalSource(FALSE),

m_deferringAST(FALSE),

m_stoppedDeferredParse(FALSE)

{

AssertMsg(size == sizeof(Parser), "verify conditionals affecting the size of Parser agree");

Assert(scriptContext != nullptr);

// init PID members

InitPids();

}

Parser::~Parser(void)

{

this->ReleaseTemporaryGuestArena();

#if ENABLE_BACKGROUND_PARSING

if (this->m_hasParallelJob)

{

// Let the background threads know that they can decommit their arena pages.

BackgroundParser *bgp = m_scriptContext->GetBackgroundParser();

Assert(bgp);

if (bgp->Processor()->ProcessesInBackground())

{

JsUtil::BackgroundJobProcessor *processor = static_cast<JsUtil::BackgroundJobProcessor*>(bgp->Processor());

bool result = processor->IterateBackgroundThreads([&](JsUtil::ParallelThreadData *threadData)->bool {

threadData->canDecommit = true;

return false;

});

Assert(result);

}

}

#endif

}

void Parser::OutOfMemory()

{

throw ParseExceptionObject(ERRnoMemory);

}

void Parser::Error(HRESULT hr)

{

throw ParseExceptionObject(hr);

}

void Parser::Error(HRESULT hr, ParseNodePtr pnode)

{

if (pnode && pnode->ichLim)

{

Error(hr, pnode->ichMin, pnode->ichLim);

}

else

{

Error(hr);

}

}

void Parser::Error(HRESULT hr, charcount_t ichMin, charcount_t ichLim)

{

this->GetScanner()->SetErrorPosition(ichMin, ichLim);

Error(hr);

}

void Parser::IdentifierExpectedError(const Token& token)

{

Assert(token.tk != tkID);

HRESULT hr;

if (token.IsReservedWord())

{

if (token.IsKeyword())

{

hr = ERRKeywordNotId;

}

else

{

Assert(token.IsFutureReservedWord(true));

if (token.IsFutureReservedWord(false))

{

// Future reserved word in strict and non-strict modes

hr = ERRFutureReservedWordNotId;

}

else

{

// Future reserved word only in strict mode. The token would have been converted to tkID by the scanner if not

// in strict mode.

Assert(IsStrictMode());

hr = ERRFutureReservedWordInStrictModeNotId;

}

}

}

else

{

hr = ERRnoIdent;

}

Error(hr);

}

HRESULT Parser::ValidateSyntax(LPCUTF8 pszSrc, size_t encodedCharCount, bool isGenerator, bool isAsync, CompileScriptException *pse, void (Parser::*validateFunction)())

{

Assert(pszSrc);

PROBE_STACK_NO_DISPOSE(m_scriptContext, Js::Constants::MinStackDefault);

HRESULT hr;

SmartFPUControl smartFpuControl;

BOOL fDeferSave = m_deferringAST;

try

{

hr = NOERROR;

m_length = encodedCharCount;

m_originalLength = encodedCharCount;

// make sure deferred parsing is turned off

ULONG grfscr = fscrNil;

// Give the scanner the source and get the first token

this->GetScanner()->SetText(pszSrc, 0, encodedCharCount, 0, false, grfscr);

this->GetScanner()->SetYieldIsKeywordRegion(isGenerator);

this->GetScanner()->SetAwaitIsKeywordRegion(isAsync);

this->GetScanner()->Scan();

uint nestedCount = 0;

m_pnestedCount = &nestedCount;

ParseNodePtr pnodeScope = nullptr;

m_ppnodeScope = &pnodeScope;

m_ppnodeExprScope = nullptr;

uint nextFunctionId = 0;

m_nextFunctionId = &nextFunctionId;

m_inDeferredNestedFunc = false;

m_deferringAST = true;

m_nextBlockId = 0;

ParseNodeFnc *pnodeFnc = CreateAllowDeferNodeForOpT<knopFncDecl>();

pnodeFnc->SetIsGenerator(isGenerator);

pnodeFnc->SetIsAsync(isAsync);

m_ppnodeVar = &pnodeFnc->pnodeVars;

m_currentNodeFunc = pnodeFnc;

m_currentNodeDeferredFunc = NULL;

m_sourceContextInfo = nullptr;

AssertMsg(m_pstmtCur == NULL, "Statement stack should be empty when we start parse function body");

ParseNodeBlock * block = StartParseBlock<false>(PnodeBlockType::Function, ScopeType_FunctionBody);

(this->*validateFunction)();

FinishParseBlock(block);

pnodeFnc->ichLim = this->GetScanner()->IchLimTok();

pnodeFnc->cbLim = this->GetScanner()->IecpLimTok();

pnodeFnc->pnodeVars = nullptr;

// there should be nothing after successful parsing for a given construct

if (m_token.tk != tkEOF)

Error(ERRsyntax);

m_deferringAST = fDeferSave;

}

catch (ParseExceptionObject& e)

{

m_deferringAST = fDeferSave;

hr = e.GetError();

}

if (nullptr != pse && FAILED(hr))

{

hr = pse->ProcessError(this->GetScanner(), hr, /* pnodeBase */ NULL);

}

return hr;

}

HRESULT Parser::ParseSourceInternal(

__out ParseNodeProg ** parseTree, LPCUTF8 pszSrc, size_t offsetInBytes, size_t encodedCharCount, charcount_t offsetInChars,

bool isUtf8, ULONG grfscr, CompileScriptException *pse, Js::LocalFunctionId * nextFunctionId, ULONG lineNumber, SourceContextInfo * sourceContextInfo)

{

Assert(parseTree);

Assert(pszSrc);

if (this->IsBackgroundParser())

{

PROBE_STACK_NO_DISPOSE(m_scriptContext, Js::Constants::MinStackDefault);

}

else

{

PROBE_STACK(m_scriptContext, Js::Constants::MinStackDefault);

}

#ifdef PROFILE_EXEC

m_scriptContext->ProfileBegin(Js::ParsePhase);

#endif

JS_ETW_INTERNAL(EventWriteJSCRIPT_PARSE_START(m_scriptContext, 0));

*parseTree = NULL;

m_sourceLim = 0;

m_grfscr = grfscr;

m_sourceContextInfo = sourceContextInfo;

ParseNodeProg * pnodeBase = NULL;

HRESULT hr;

SmartFPUControl smartFpuControl;

try

{

if ((grfscr & fscrIsModuleCode) != 0)

{

// Module source flag should not be enabled unless module is enabled

Assert(m_scriptContext->GetConfig()->IsES6ModuleEnabled());

// Module code is always strict mode code.

this->m_fUseStrictMode = TRUE;

}

// parse the source

pnodeBase = Parse(pszSrc, offsetInBytes, encodedCharCount, offsetInChars, isUtf8, grfscr, lineNumber, nextFunctionId, pse);

Assert(pnodeBase);

// Record the actual number of words parsed.

m_sourceLim = pnodeBase->ichLim - offsetInChars;

// TODO: The assert can be false positive in some scenarios and chuckj to fix it later

// Assert(utf8::ByteIndexIntoCharacterIndex(pszSrc + offsetInBytes, encodedCharCount, isUtf8 ? utf8::doDefault : utf8::doAllowThreeByteSurrogates) == m_sourceLim);

#if DBG_DUMP

if (Js::Configuration::Global.flags.Trace.IsEnabled(Js::ParsePhase))

{

PrintPnodeWIndent(pnodeBase, 4);

fflush(stdout);

}

#endif

*parseTree = pnodeBase;

hr = NOERROR;

}

catch (ParseExceptionObject& e)

{

hr = e.GetError();

}

catch (Js::AsmJsParseException&)

{

hr = JSERR_AsmJsCompileError;

}

if (FAILED(hr))

{

hr = pse->ProcessError(this->GetScanner(), hr, pnodeBase);

}

#if ENABLE_BACKGROUND_PARSING

if (this->m_hasParallelJob)

{

///// Wait here for remaining jobs to finish. Then look for errors, do final const bindings.

// pleath TODO: If there are remaining jobs, let the main thread help finish them.

BackgroundParser *bgp = m_scriptContext->GetBackgroundParser();

Assert(bgp);

CompileScriptException se;

this->WaitForBackgroundJobs(bgp, &se);

BackgroundParseItem *failedItem = bgp->GetFailedBackgroundParseItem();

if (failedItem)

{

CompileScriptException *bgPse = failedItem->GetPSE();

Assert(bgPse);

*pse = *bgPse;

hr = failedItem->GetHR();

bgp->SetFailedBackgroundParseItem(nullptr);

}

if (this->fastScannedRegExpNodes != nullptr)

{

this->FinishBackgroundRegExpNodes();

}

for (BackgroundParseItem *item = this->backgroundParseItems; item; item = item->GetNext())

{

Parser *parser = item->GetParser();

parser->FinishBackgroundPidRefs(item, this != parser);

}

}

#endif

// done with the scanner

this->GetScanner()->Clear();

#ifdef PROFILE_EXEC

m_scriptContext->ProfileEnd(Js::ParsePhase);

#endif

JS_ETW_INTERNAL(EventWriteJSCRIPT_PARSE_STOP(m_scriptContext, 0));

return hr;

}

#if ENABLE_BACKGROUND_PARSING

void Parser::WaitForBackgroundJobs(BackgroundParser *bgp, CompileScriptException *pse)

{

// The scan of the script is done, but there may be unfinished background jobs in the queue.

// Enlist the main thread to help with those.

BackgroundParseItem *item;

if (!*bgp->GetPendingBackgroundItemsPtr())

{

// We're done.

return;

}

// Save parser state, since we'll need to restore it in order to bind references correctly later.

this->m_isInBackground = true;

this->SetCurrBackgroundParseItem(nullptr);

uint blockIdSave = this->m_nextBlockId;

uint functionIdSave = *this->m_nextFunctionId;

StmtNest *pstmtSave = this->m_pstmtCur;

if (!bgp->Processor()->ProcessesInBackground())

{

// No background thread. Just walk the jobs with no locking and process them.

for (item = bgp->GetNextUnprocessedItem(); item; item = bgp->GetNextUnprocessedItem())

{

bgp->Processor()->RemoveJob(item);

bool succeeded = bgp->Process(item, this, pse);

bgp->JobProcessed(item, succeeded);

}

Assert(!*bgp->GetPendingBackgroundItemsPtr());

}

else

{

// Background threads. We need to have the critical section in order to:

// - Check for unprocessed jobs;

// - Remove jobs from the processor queue;

// - Do JobsProcessed work (such as removing jobs from the BackgroundParser's unprocessed list).

CriticalSection *pcs = static_cast<JsUtil::BackgroundJobProcessor*>(bgp->Processor())->GetCriticalSection();

pcs->Enter();

for (;;)

{

// Grab a job (in lock)

item = bgp->GetNextUnprocessedItem();

if (item == nullptr)

{

break;

}

bgp->Processor()->RemoveJob(item);

pcs->Leave();

// Process job (if there is one) (outside lock)

bool succeeded = bgp->Process(item, this, pse);

pcs->Enter();

bgp->JobProcessed(item, succeeded);

}

pcs->Leave();

// Wait for the background threads to finish jobs they're already processing (if any).

// TODO: Replace with a proper semaphore.

while (*bgp->GetPendingBackgroundItemsPtr());

}

Assert(!*bgp->GetPendingBackgroundItemsPtr());

// Restore parser state.

this->m_pstmtCur = pstmtSave;

this->m_isInBackground = false;

this->m_nextBlockId = blockIdSave;

*this->m_nextFunctionId = functionIdSave;

}

void Parser::FinishBackgroundPidRefs(BackgroundParseItem *item, bool isOtherParser)

{

for (BlockInfoStack *blockInfo = item->GetParseContext()->currentBlockInfo; blockInfo; blockInfo = blockInfo->pBlockInfoOuter)

{

if (isOtherParser)

{

this->BindPidRefs<true>(blockInfo, item->GetMaxBlockId());

}

else

{

this->BindPidRefs<false>(blockInfo, item->GetMaxBlockId());

}

}

}

void Parser::FinishBackgroundRegExpNodes()

{

// We have a list of RegExp nodes that we saw on the UI thread in functions we're parallel parsing,

// and for each background job we have a list of RegExp nodes for which we couldn't allocate patterns.

// We need to copy the pattern pointers from the UI thread nodes to the corresponding nodes on the

// background nodes.

// There may be UI thread nodes for which there are no background thread equivalents, because the UI thread

// has to assume that the background thread won't defer anything.

// Note that because these lists (and the list of background jobs) are SList's built by prepending, they are

// all in reverse lexical order.

Assert(!this->IsBackgroundParser());

Assert(this->fastScannedRegExpNodes);

Assert(this->backgroundParseItems != nullptr);

BackgroundParseItem *currBackgroundItem;

#if DBG

for (currBackgroundItem = this->backgroundParseItems;

currBackgroundItem;

currBackgroundItem = currBackgroundItem->GetNext())

{

if (currBackgroundItem->RegExpNodeList())

{

FOREACH_DLIST_ENTRY(ParseNodePtr, ArenaAllocator, pnode, currBackgroundItem->RegExpNodeList())

{

Assert(pnode->AsParseNodeRegExp()->regexPattern == nullptr);

}

NEXT_DLIST_ENTRY;

}

}

#endif

// Hook up the patterns allocated on the main thread to the nodes created on the background thread.

// Walk the list of foreground nodes, advancing through the work items and looking up each item.

// Note that the background thread may have chosen to defer a given RegEx literal, so not every foreground

// node will have a matching background node. Doesn't matter for correctness.

// (It's inefficient, of course, to have to restart the inner loop from the beginning of the work item's

// list, but it should be unusual to have many RegExes in a single work item's chunk of code. Figure out how

// to start the inner loop from a known internal node within the list if that turns out to be important.)

currBackgroundItem = this->backgroundParseItems;

FOREACH_DLIST_ENTRY(ParseNodePtr, ArenaAllocator, pnodeFgnd, this->fastScannedRegExpNodes)

{

Assert(pnodeFgnd->nop == knopRegExp);

Assert(pnodeFgnd->AsParseNodeRegExp()->regexPattern != nullptr);

bool quit = false;

while (!quit)

{

// Find the next work item with a RegEx in it.

while (currBackgroundItem && currBackgroundItem->RegExpNodeList() == nullptr)

{

currBackgroundItem = currBackgroundItem->GetNext();

}

if (!currBackgroundItem)

{

break;

}

// Walk the RegExps in the work item.

FOREACH_DLIST_ENTRY(ParseNodePtr, ArenaAllocator, pnodeBgnd, currBackgroundItem->RegExpNodeList())

{

Assert(pnodeBgnd->nop == knopRegExp);

if (pnodeFgnd->ichMin <= pnodeBgnd->ichMin)

{

// Either we found a match, or the next background node is past the foreground node.

// In any case, we can stop searching.

if (pnodeFgnd->ichMin == pnodeBgnd->ichMin)

{

Assert(pnodeFgnd->ichLim == pnodeBgnd->ichLim);

pnodeBgnd->AsParseNodeRegExp()->regexPattern = pnodeFgnd->AsParseNodeRegExp()->regexPattern;

}

quit = true;

break;

}

}

NEXT_DLIST_ENTRY;

if (!quit)

{

// Need to advance to the next work item.

currBackgroundItem = currBackgroundItem->GetNext();

}

}

}

NEXT_DLIST_ENTRY;

#if DBG

for (currBackgroundItem = this->backgroundParseItems;

currBackgroundItem;

currBackgroundItem = currBackgroundItem->GetNext())

{

if (currBackgroundItem->RegExpNodeList())

{

FOREACH_DLIST_ENTRY(ParseNodePtr, ArenaAllocator, pnode, currBackgroundItem->RegExpNodeList())

{

Assert(pnode->AsParseNodeRegExp()->regexPattern != nullptr);

}

NEXT_DLIST_ENTRY;

}

}

#endif

}

#endif

LabelId* Parser::CreateLabelId(IdentPtr pid)

{

LabelId* pLabelId;

pLabelId = (LabelId*)m_nodeAllocator.Alloc(sizeof(LabelId));

if (NULL == pLabelId)

Error(ERRnoMemory);

pLabelId->pid = pid;

pLabelId->next = NULL;

return pLabelId;

}

/*****************************************************************************

The following set of routines allocate parse tree nodes of various kinds.

They catch an exception on out of memory.

*****************************************************************************/

void

Parser::AddAstSize(int size)

{

Assert(!this->m_deferringAST);

Assert(m_pCurrentAstSize != NULL);

*m_pCurrentAstSize += size;

}

void

Parser::AddAstSizeAllowDefer(int size)

{

if (!this->m_deferringAST)

{

AddAstSize(size);

}

}

// StaticCreate

ParseNodeVar * Parser::StaticCreateTempNode(ParseNode* initExpr, ArenaAllocator * alloc)

{

ParseNodeVar * pnode = Anew(alloc, ParseNodeVar, knopTemp, 0, 0, nullptr);

pnode->pnodeInit = initExpr;

return pnode;

}

ParseNodeUni * Parser::StaticCreateTempRef(ParseNode* tempNode, ArenaAllocator * alloc)

{

return Anew(alloc, ParseNodeUni, knopTempRef, 0, 0, tempNode);

}

// Create Node with limit

template <OpCode nop>

typename OpCodeTrait<nop>::ParseNodeType * Parser::CreateNodeForOpT(charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

typename OpCodeTrait<nop>::ParseNodeType * pnode = StaticCreateNodeT<nop>(&m_nodeAllocator, ichMin, ichLim);

AddAstSize(sizeof(typename OpCodeTrait<nop>::ParseNodeType));

return pnode;

}

template <OpCode nop>

typename OpCodeTrait<nop>::ParseNodeType * Parser::CreateAllowDeferNodeForOpT(charcount_t ichMin, charcount_t ichLim)

{

CompileAssert(OpCodeTrait<nop>::AllowDefer);

typename OpCodeTrait<nop>::ParseNodeType * pnode = StaticCreateNodeT<nop>(&m_nodeAllocator, ichMin, ichLim);

AddAstSizeAllowDefer(sizeof(typename OpCodeTrait<nop>::ParseNodeType));

return pnode;

}

#if DBG

static const int g_mpnopcbNode[] =

{

#define PTNODE(nop,sn,pc,nk,ok,json) sizeof(ParseNode##nk),

#include "ptlist.h"

};

void VerifyNodeSize(OpCode nop, int size)

{

Assert(nop >= 0 && nop < knopLim);

__analysis_assume(nop < knopLim);

Assert(g_mpnopcbNode[nop] == size);

}

#endif

// Create ParseNodeUni

ParseNodeUni * Parser::CreateUniNode(OpCode nop, ParseNodePtr pnode1)

{

charcount_t ichMin;

charcount_t ichLim;

if (nullptr == pnode1)

{

// no ops

ichMin = this->GetScanner()->IchMinTok();

ichLim = this->GetScanner()->IchLimTok();

}

else

{

// 1 op

ichMin = pnode1->ichMin;

ichLim = pnode1->ichLim;

this->CheckArguments(pnode1);

}

return CreateUniNode(nop, pnode1, ichMin, ichLim);

}

ParseNodeUni * Parser::CreateUniNode(OpCode nop, ParseNodePtr pnode1, charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

DebugOnly(VerifyNodeSize(nop, sizeof(ParseNodeUni)));

ParseNodeUni * pnode = Anew(&m_nodeAllocator, ParseNodeUni, nop, ichMin, ichLim, pnode1);

AddAstSize(sizeof(ParseNodeUni));

return pnode;

}

// Create ParseNodeBin

ParseNodeBin * Parser::StaticCreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, ArenaAllocator* alloc, charcount_t ichMin, charcount_t ichLim)

{

DebugOnly(VerifyNodeSize(nop, sizeof(ParseNodeBin)));

return Anew(alloc, ParseNodeBin, nop, ichMin, ichLim, pnode1, pnode2);

}

ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2)

{

Assert(!this->m_deferringAST);

charcount_t ichMin;

charcount_t ichLim;

if (nullptr == pnode1)

{

// no ops

Assert(nullptr == pnode2);

ichMin = this->GetScanner()->IchMinTok();

ichLim = this->GetScanner()->IchLimTok();

}

else

{

if (nullptr == pnode2)

{

// 1 op

ichMin = pnode1->ichMin;

ichLim = pnode1->ichLim;

}

else

{

// 2 ops

ichMin = pnode1->ichMin;

ichLim = pnode2->ichLim;

if (nop != knopDot && nop != knopIndex)

{

this->CheckArguments(pnode2);

}

}

if (nop != knopDot && nop != knopIndex)

{

this->CheckArguments(pnode1);

}

}

return CreateBinNode(nop, pnode1, pnode2, ichMin, ichLim);

}

ParseNodeBin * Parser::CreateBinNode(OpCode nop, ParseNodePtr pnode1,

ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

ParseNodeBin * pnode = StaticCreateBinNode(nop, pnode1, pnode2, &m_nodeAllocator, ichMin, ichLim);

AddAstSize(sizeof(ParseNodeBin));

return pnode;

}

// Create ParseNodeTri

ParseNodeTri * Parser::CreateTriNode(OpCode nop, ParseNodePtr pnode1,

ParseNodePtr pnode2, ParseNodePtr pnode3)

{

charcount_t ichMin;

charcount_t ichLim;

if (nullptr == pnode1)

{

// no ops

Assert(nullptr == pnode2);

Assert(nullptr == pnode3);

ichMin = this->GetScanner()->IchMinTok();

ichLim = this->GetScanner()->IchLimTok();

}

else if (nullptr == pnode2)

{

// 1 op

Assert(nullptr == pnode3);

ichMin = pnode1->ichMin;

ichLim = pnode1->ichLim;

}

else if (nullptr == pnode3)

{

// 2 op

ichMin = pnode1->ichMin;

ichLim = pnode2->ichLim;

}

else

{

// 3 ops

ichMin = pnode1->ichMin;

ichLim = pnode3->ichLim;

}

return CreateTriNode(nop, pnode1, pnode2, pnode3, ichMin, ichLim);

}

ParseNodeTri * Parser::CreateTriNode(OpCode nop, ParseNodePtr pnode1,

ParseNodePtr pnode2, ParseNodePtr pnode3,

charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

DebugOnly(VerifyNodeSize(nop, sizeof(ParseNodeTri)));

ParseNodeTri * pnode = Anew(&m_nodeAllocator, ParseNodeTri, nop, ichMin, ichLim);

AddAstSize(sizeof(ParseNodeTri));

pnode->pnode1 = pnode1;

pnode->pnode2 = pnode2;

pnode->pnode3 = pnode3;

return pnode;

}

// Create ParseNodeBlock

ParseNodeBlock *

Parser::StaticCreateBlockNode(ArenaAllocator* alloc, charcount_t ichMin, charcount_t ichLim, int blockId, PnodeBlockType blockType)

{

return Anew(alloc, ParseNodeBlock, ichMin, ichLim, blockId, blockType);

}

ParseNodeBlock * Parser::CreateBlockNode(PnodeBlockType blockType)

{

return CreateBlockNode(this->GetScanner()->IchMinTok(), this->GetScanner()->IchLimTok(), blockType);

}

ParseNodeBlock * Parser::CreateBlockNode(charcount_t ichMin, charcount_t ichLim, PnodeBlockType blockType)

{

Assert(OpCodeTrait<knopBlock>::AllowDefer);

ParseNodeBlock * pnode = StaticCreateBlockNode(&m_nodeAllocator, ichMin, ichLim, this->m_nextBlockId++, blockType);

AddAstSizeAllowDefer(sizeof(ParseNodeBlock));

return pnode;

}

// Create ParseNodeVar

ParseNodeVar * Parser::CreateDeclNode(OpCode nop, IdentPtr pid, SymbolType symbolType, bool errorOnRedecl)

{

Assert(nop == knopVarDecl || nop == knopLetDecl || nop == knopConstDecl);

ParseNodeVar * pnode = Anew(&m_nodeAllocator, ParseNodeVar, nop, this->GetScanner()->IchMinTok(), this->GetScanner()->IchLimTok(), pid);

if (symbolType != STUnknown)

{

pnode->sym = AddDeclForPid(pnode, pid, symbolType, errorOnRedecl);

}

return pnode;

}

ParseNodeInt * Parser::CreateIntNode(int32 lw)

{

Assert(!this->m_deferringAST);

ParseNodeInt * pnode = Anew(&m_nodeAllocator, ParseNodeInt, this->GetScanner()->IchMinTok(), this->GetScanner()->IchLimTok(), lw);

AddAstSize(sizeof(ParseNodeInt));

return pnode;

}

ParseNodeStr * Parser::CreateStrNode(IdentPtr pid)

{

Assert(!this->m_deferringAST);

ParseNodeStr * pnode = Anew(&m_nodeAllocator, ParseNodeStr, this->GetScanner()->IchMinTok(), this->GetScanner()->IchLimTok(), pid);

pnode->grfpn |= PNodeFlags::fpnCanFlattenConcatExpr;

AddAstSize(sizeof(ParseNodeStr));

return pnode;

}

ParseNodeName * Parser::CreateNameNode(IdentPtr pid)

{

ParseNodeName * pnode = Anew(&m_nodeAllocator, ParseNodeName, this->GetScanner()->IchMinTok(), this->GetScanner()->IchLimTok(), pid);

AddAstSizeAllowDefer(sizeof(ParseNodeName));

return pnode;

}

ParseNodeName * Parser::CreateNameNode(IdentPtr pid, PidRefStack * ref, charcount_t ichMin, charcount_t ichLim)

{

ParseNodeName * pnode = Anew(&m_nodeAllocator, ParseNodeName, ichMin, ichLim, pid);

pnode->SetSymRef(ref);

AddAstSize(sizeof(ParseNodeName));

return pnode;

}

ParseNodeSpecialName * Parser::CreateSpecialNameNode(IdentPtr pid, PidRefStack * ref, charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

ParseNodeSpecialName * pnode = Anew(&m_nodeAllocator, ParseNodeSpecialName, ichMin, ichLim, pid);

pnode->SetSymRef(ref);

if (pid == wellKnownPropertyPids._this)

{

pnode->isThis = true;

}

else if (pid == wellKnownPropertyPids._super || pid == wellKnownPropertyPids._superConstructor)

{

pnode->isSuper = true;

}

AddAstSize(sizeof(ParseNodeSpecialName));

return pnode;

}

ParseNodeSuperReference * Parser::CreateSuperReferenceNode(OpCode nop, ParseNodeSpecialName * pnode1, ParseNodePtr pnode2)

{

Assert(!this->m_deferringAST);

Assert(pnode1 && pnode1->isSuper);

Assert(pnode2 != nullptr);

Assert(nop == knopDot || nop == knopIndex);

ParseNodeSuperReference * pnode = Anew(&m_nodeAllocator, ParseNodeSuperReference, nop, pnode1->ichMin, pnode2->ichLim, pnode1, pnode2);

AddAstSize(sizeof(ParseNodeSuperReference));

return pnode;

}

ParseNodeProg * Parser::CreateProgNode(bool isModuleSource, ULONG lineNumber)

{

ParseNodeProg * pnodeProg;

if (isModuleSource)

{

pnodeProg = CreateNodeForOpT<knopModule>();

// knopModule is not actually handled anywhere since we would need to handle it everywhere we could

// have knopProg and it would be treated exactly the same except for import/export statements.

// We are only using it as a way to get the correct size for PnModule.

// Consider: Should we add a flag to PnProg which is false but set to true in PnModule?

// If we do, it can't be a virtual method since the parse nodes are all in a union.

pnodeProg->nop = knopProg;

}

else

{

pnodeProg = CreateNodeForOpT<knopProg>();

}

pnodeProg->cbMin = this->GetScanner()->IecpMinTok();

pnodeProg->cbStringMin = pnodeProg->cbMin;

pnodeProg->lineNumber = lineNumber;

pnodeProg->homeObjLocation = Js::Constants::NoRegister;

pnodeProg->superRestrictionState = SuperRestrictionState::Disallowed;

return pnodeProg;

}

ParseNodeCall * Parser::CreateCallNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2)

{

charcount_t ichMin;

charcount_t ichLim;

if (nullptr == pnode1)

{

Assert(nullptr == pnode2);

ichMin = this->GetScanner()->IchMinTok();

ichLim = this->GetScanner()->IchLimTok();

}

else

{

ichMin = pnode1->ichMin;

ichLim = pnode2 == nullptr ? pnode1->ichLim : pnode2->ichLim;

if (pnode1->nop == knopDot || pnode1->nop == knopIndex)

{

this->CheckArguments(pnode1->AsParseNodeBin()->pnode1);

}

}

return CreateCallNode(nop, pnode1, pnode2, ichMin, ichLim);

}

ParseNodeCall * Parser::CreateCallNode(OpCode nop, ParseNodePtr pnode1, ParseNodePtr pnode2, charcount_t ichMin, charcount_t ichLim)

{

Assert(!this->m_deferringAST);

// Classes, derived from ParseNodeCall, can be created here as well,

// as long as their size matches kcbPnCall (that is, they don't add

// any data members of their own).

DebugOnly(VerifyNodeSize(nop, sizeof(ParseNodeCall)));

ParseNodeCall* pnode = Anew(&m_nodeAllocator, ParseNodeCall, nop, ichMin, ichLim, pnode1, pnode2);

AddAstSize(sizeof(ParseNodeCall));