#include "config.h"

#include "Parser.h"

#include "ASTBuilder.h"

#include "BuiltinNames.h"

#include "DebuggerParseData.h"

#include "JSCJSValueInlines.h"

#include "VM.h"

#include <utility>

#include <wtf/Scope.h>

#include <wtf/SetForScope.h>

#include <wtf/StringPrintStream.h>

#define updateErrorMessage(shouldPrintToken, ...) do {\

propagateError(); \

logError(shouldPrintToken, __VA_ARGS__); \

} while (0)

#define propagateError() do { if (UNLIKELY(hasError())) return 0; } while (0)

#define internalFailWithMessage(shouldPrintToken, ...) do { updateErrorMessage(shouldPrintToken, __VA_ARGS__); return 0; } while (0)

#define handleErrorToken() do { if (m_token.m_type == EOFTOK || m_token.m_type & CanBeErrorTokenFlag) { failDueToUnexpectedToken(); } } while (0)

#define failWithMessage(...) do { { handleErrorToken(); updateErrorMessage(true, __VA_ARGS__); } return 0; } while (0)

#define failWithStackOverflow() do { updateErrorMessage(false, "Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)

#define failIfFalse(cond, ...) do { if (!(cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfTrue(cond, ...) do { if (cond) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfTrueIfStrict(cond, ...) do { if ((cond) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define failIfFalseIfStrict(cond, ...) do { if ((!(cond)) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define consumeOrFail(tokenType, ...) do { if (!consume(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define consumeOrFailWithFlags(tokenType, flags, ...) do { if (!consume(tokenType, flags)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define matchOrFail(tokenType, ...) do { if (!match(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfStackOverflow() do { if (UNLIKELY(!canRecurse())) failWithStackOverflow(); } while (0)

#define semanticFail(...) do { internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define semanticFailIfTrue(cond, ...) do { if (UNLIKELY(cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define semanticFailIfFalse(cond, ...) do { if (UNLIKELY(!(cond))) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define regexFail(failure) do { setErrorMessage(failure); return 0; } while (0)

#define failDueToUnexpectedToken() do {\

logError(true);\

return 0;\

} while (0)

#define handleProductionOrFail(token, tokenString, operation, production) do {\

consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " a ", production);\

} while (0)

#define handleProductionOrFail2(token, tokenString, operation, production) do {\

consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " an ", production);\

} while (0)

#define semanticFailureDueToKeywordCheckingToken(token, ...) do { \

if (strictMode() && token.m_type == RESERVED_IF_STRICT) \

semanticFail("Cannot use the reserved word '", getToken(token), "' as a ", __VA_ARGS__, " in strict mode"); \

if (token.m_type == RESERVED || token.m_type == RESERVED_IF_STRICT) \

semanticFail("Cannot use the reserved word '", getToken(token), "' as a ", __VA_ARGS__); \

if (token.m_type & KeywordTokenFlag) { \

if (!isContextualKeyword(token)) \

semanticFail("Cannot use the keyword '", getToken(token), "' as a ", __VA_ARGS__); \

if (token.m_type == LET && strictMode())\

semanticFail("Cannot use 'let' as a ", __VA_ARGS__, " ", disallowedIdentifierLetReason()); \

if (token.m_type == AWAIT && !canUseIdentifierAwait()) \

semanticFail("Cannot use 'await' as a ", __VA_ARGS__, " ", disallowedIdentifierAwaitReason()); \

if (token.m_type == YIELD && !canUseIdentifierYield()) \

semanticFail("Cannot use 'yield' as a ", __VA_ARGS__, " ", disallowedIdentifierYieldReason()); \

} \

} while (0)

#define semanticFailureDueToKeyword(...) semanticFailureDueToKeywordCheckingToken(m_token, __VA_ARGS__);

namespace JSC {

std::atomic<unsigned> globalParseCount { 0 };

ALWAYS_INLINE static SourceParseMode getAsynFunctionBodyParseMode(SourceParseMode parseMode)

}

template <typename LexerType>

void Parser<LexerType>::logError(bool)

{

if (hasError())

return;

StringPrintStream stream;

printUnexpectedTokenText(stream);

setErrorMessage(stream.toStringWithLatin1Fallback());

}

template <typename LexerType> template <typename... Args>

void Parser<LexerType>::logError(bool shouldPrintToken, Args&&... args)

{

if (hasError())

return;

StringPrintStream stream;

if (shouldPrintToken) {

printUnexpectedTokenText(stream);

stream.print(". ");

}

stream.print(std::forward<Args>(args)..., ".");

setErrorMessage(stream.toStringWithLatin1Fallback());

}

template <typename LexerType>

Parser<LexerType>::Parser(VM& vm, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKindForTopLevelFunction, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType, DebuggerParseData* debuggerParseData, bool isInsideOrdinaryFunction)

: m_vm(vm)

, m_source(&source)

, m_hasStackOverflow(false)

, m_allowsIn(true)

, m_statementDepth(0)

, m_parsingBuiltin(builtinMode == JSParserBuiltinMode::Builtin)

, m_parseMode(parseMode)

, m_scriptMode(scriptMode)

, m_superBinding(superBinding)

, m_defaultConstructorKindForTopLevelFunction(defaultConstructorKindForTopLevelFunction)

, m_immediateParentAllowsFunctionDeclarationInStatement(false)

, m_debuggerParseData(debuggerParseData)

, m_isInsideOrdinaryFunction(isInsideOrdinaryFunction)

{

m_lexer = makeUnique<LexerType>(vm, builtinMode, scriptMode);

m_lexer->setCode(source, &m_parserArena);

m_token.m_location.line = source.firstLine().oneBasedInt();

m_token.m_location.startOffset = source.startOffset();

m_token.m_location.endOffset = source.startOffset();

m_token.m_location.lineStartOffset = source.startOffset();

m_functionCache = vm.addSourceProviderCache(source.provider());

m_expressionErrorClassifier = nullptr;

ScopeRef scope = pushScope();

scope->setSourceParseMode(parseMode);

scope->setIsEvalContext(isEvalContext);

if (isEvalContext)

scope->setEvalContextType(evalContextType);

if (derivedContextType == DerivedContextType::DerivedConstructorContext) {

scope->setConstructorKind(ConstructorKind::Extends);

scope->setExpectedSuperBinding(SuperBinding::Needed);

}

if (derivedContextType == DerivedContextType::DerivedMethodContext)

scope->setExpectedSuperBinding(SuperBinding::Needed);

if (strictMode == JSParserStrictMode::Strict)

scope->setStrictMode();

if (isModuleParseMode(parseMode))

m_moduleScopeData = ModuleScopeData::create();

if (isProgramOrModuleParseMode(parseMode))

scope->setIsGlobalCodeScope();

next();

}

class Scope::MaybeParseAsGeneratorForScope {

MaybeParseAsGeneratorForScope(ScopeRef& scope, bool shouldParseAsGenerator)

}

~MaybeParseAsGeneratorForScope()

{

m_scope->m_isGenerator = m_oldValue;

}

ScopeRef m_scope;

bool m_oldValue;

};

struct DepthManager : private SetForScope<int> {

};

template <typename LexerType>

Parser<LexerType>::~Parser()

{

}

void JSToken::dump(PrintStream& out) const

{

out.print(*m_data.cooked);

}

static ALWAYS_INLINE bool isPrivateFieldName(UniquedStringImpl* uid)

{

return uid->length() && uid->at(0) == '#';

}

template <typename LexerType>

Expected<typename Parser<LexerType>::ParseInnerResult, String> Parser<LexerType>::parseInner(const Identifier& calleeName, ParsingContext parsingContext, std::optional<int> functionConstructorParametersEndPosition, const FixedVector<JSTextPosition>* classFieldLocations, const PrivateNameEnvironment* parentScopePrivateNames)

{

ASTBuilder context(const_cast<VM&>(m_vm), m_parserArena, const_cast<SourceCode*>(m_source));

SourceParseMode parseMode = sourceParseMode();

ScopeRef scope = currentScope();

scope->setIsLexicalScope();

bool hasPrivateNames = scope->isEvalContext() && parentScopePrivateNames && parentScopePrivateNames->size();

if (hasPrivateNames) {

scope->setIsPrivateNameScope();

scope->lexicalVariables().addPrivateNamesFrom(parentScopePrivateNames);

}

SetForScope functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body);

FunctionParameters* parameters = nullptr;

bool isArrowFunctionBodyExpression = parseMode == SourceParseMode::AsyncArrowFunctionBodyMode && !match(OPENBRACE);

if (m_lexer->isReparsingFunction()) {

ParserFunctionInfo<ASTBuilder> functionInfo;

if (isGeneratorOrAsyncFunctionBodyParseMode(parseMode))

parameters = createGeneratorParameters(context, functionInfo.parameterCount);

else if (parseMode == SourceParseMode::ClassFieldInitializerMode)

parameters = context.createFormalParameterList();

else

parameters = parseFunctionParameters(context, functionInfo);

if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(parseMode) && !hasError()) {

// FIXME:

// Logically, this should be an assert, since we already successfully parsed the arrow

// function when syntax checking. So logically, we should see the arrow token here.

// But we're seeing crashes in the wild when making this an assert. Instead, we'll just

// handle it as an error in release builds, and an assert on debug builds, with the hopes

// of fixing it in the future.

// https://bugs.webkit.org/show_bug.cgi?id=221633

if (UNLIKELY(!match(ARROWFUNCTION))) {

ASSERT_NOT_REACHED();

return makeUnexpected("Parser error"_s);

}

next();

isArrowFunctionBodyExpression = !match(OPENBRACE);

}

}

if (!calleeName.isNull())

scope->declareCallee(&calleeName);

if (m_lexer->isReparsingFunction())

m_statementDepth--;

SourceElements* sourceElements = nullptr;

// The only way we can error this early is if we reparse a function and we run out of stack space.

if (!hasError()) {

if (isAsyncFunctionWrapperParseMode(parseMode))

sourceElements = parseAsyncFunctionSourceElements(context, isArrowFunctionBodyExpression, CheckForStrictMode);

else if (isArrowFunctionBodyExpression)

sourceElements = parseArrowFunctionSingleExpressionBodySourceElements(context);

else if (isModuleParseMode(parseMode))

sourceElements = parseModuleSourceElements(context);

else if (isGeneratorWrapperParseMode(parseMode))

sourceElements = parseGeneratorFunctionSourceElements(context, calleeName, CheckForStrictMode);

else if (isAsyncGeneratorWrapperParseMode(parseMode))

sourceElements = parseAsyncGeneratorFunctionSourceElements(context, isArrowFunctionBodyExpression, CheckForStrictMode);

else if (parsingContext == ParsingContext::FunctionConstructor)

sourceElements = parseSingleFunction(context, functionConstructorParametersEndPosition);

else if (parseMode == SourceParseMode::ClassFieldInitializerMode) {

ASSERT(classFieldLocations && !classFieldLocations->isEmpty());

sourceElements = parseClassFieldInitializerSourceElements(context, *classFieldLocations);

} else

sourceElements = parseSourceElements(context, CheckForStrictMode);

}

bool validEnding = consume(EOFTOK);

if (!sourceElements || !validEnding)

return makeUnexpected(hasError() ? m_errorMessage : "Parser error"_s);

if (!m_lexer->isReparsingFunction() && m_seenPrivateNameUseInNonReparsingFunctionMode) {

String errorMessage;

scope->forEachUsedVariable([&] (UniquedStringImpl* impl) {

if (!isPrivateFieldName(impl))

return IterationStatus::Continue;

if (parentScopePrivateNames && parentScopePrivateNames->contains(impl))

return IterationStatus::Continue;

if (scope->lexicalVariables().contains(impl))

return IterationStatus::Continue;

errorMessage = makeString("Cannot reference undeclared private names: \"", String(impl), "\"");

return IterationStatus::Done;

});

if (!errorMessage.isNull())

return makeUnexpected(errorMessage);

}

IdentifierSet capturedVariables;

UniquedStringImplPtrSet sloppyModeHoistedFunctions;

scope->getSloppyModeHoistedFunctions(sloppyModeHoistedFunctions);

scope->getCapturedVars(capturedVariables);

VariableEnvironment& varDeclarations = scope->declaredVariables();

for (auto& entry : capturedVariables)

varDeclarations.markVariableAsCaptured(entry);

scope->finalizeLexicalEnvironment();

if (isGeneratorWrapperParseMode(parseMode) || isAsyncFunctionOrAsyncGeneratorWrapperParseMode(parseMode)) {

if (scope->usedVariablesContains(m_vm.propertyNames->arguments.impl()))

context.propagateArgumentsUse();

}

CodeFeatures features = context.features();

if (scope->shadowsArguments())

features |= ShadowsArgumentsFeature;

if (m_seenTaggedTemplateInNonReparsingFunctionMode)

features |= NoEvalCacheFeature;

if (scope->hasNonSimpleParameterList())

features |= NonSimpleParameterListFeature;

#if ASSERT_ENABLED

if (m_parsingBuiltin && isProgramParseMode(parseMode)) {

VariableEnvironment& lexicalVariables = scope->lexicalVariables();

const HashSet<UniquedStringImpl*>& closedVariableCandidates = scope->closedVariableCandidates();

for (UniquedStringImpl* candidate : closedVariableCandidates) {

// FIXME: We allow async to leak because it appearing as a closed variable is a side effect of trying to parse async arrow functions.

if (!lexicalVariables.contains(candidate) && !varDeclarations.contains(candidate) && !candidate->isSymbol() && candidate != m_vm.propertyNames->async.impl()) {

dataLog("Bad global capture in builtin: '", candidate, "'\n");

dataLog(m_source->view());

CRASH();

}

}

}

#endif // ASSERT_ENABLED

return ParseInnerResult { parameters, sourceElements, scope->takeFunctionDeclarations(), scope->takeDeclaredVariables(), scope->takeLexicalEnvironment(), WTFMove(sloppyModeHoistedFunctions), features, context.numConstants() };

}

template <typename LexerType>

template <class TreeBuilder> bool Parser<LexerType>::isArrowFunctionParameters(TreeBuilder& context)

{

if (match(OPENPAREN)) {

SavePoint saveArrowFunctionPoint = createSavePoint(context);

next();

bool isArrowFunction = false;

if (match(CLOSEPAREN)) {

next();

isArrowFunction = match(ARROWFUNCTION);

} else {

SyntaxChecker syntaxChecker(const_cast<VM&>(m_vm), m_lexer.get());

// We make fake scope, otherwise parseFormalParameters will add variable to current scope that lead to errors

AutoPopScopeRef fakeScope(this, pushScope());

fakeScope->setSourceParseMode(SourceParseMode::ArrowFunctionMode);

unsigned parametersCount = 0;

bool isArrowFunctionParameterList = true;

bool isMethod = false;

isArrowFunction = parseFormalParameters(syntaxChecker, syntaxChecker.createFormalParameterList(), isArrowFunctionParameterList, isMethod, parametersCount) && consume(CLOSEPAREN) && match(ARROWFUNCTION);

propagateError();

popScope(fakeScope, syntaxChecker.NeedsFreeVariableInfo);

}

restoreSavePoint(context, saveArrowFunctionPoint);

return isArrowFunction;

}

if (matchSpecIdentifier()) {

semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Cannot use 'await' as a parameter name in an async function");

SavePoint saveArrowFunctionPoint = createSavePoint(context);

next();

bool isArrowFunction = match(ARROWFUNCTION);

restoreSavePoint(context, saveArrowFunctionPoint);

return isArrowFunction;

}

return false;

}

template <typename LexerType>

bool Parser<LexerType>::allowAutomaticSemicolon()

{

return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->hasLineTerminatorBeforeToken();

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context, SourceElementsMode mode)

{

const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length

TreeSourceElements sourceElements = context.createSourceElements();

const Identifier* directive = nullptr;

unsigned directiveLiteralLength = 0;

auto savePoint = createSavePoint(context);

bool shouldCheckForUseStrict = mode == CheckForStrictMode;

while (TreeStatement statement = parseStatementListItem(context, directive, &directiveLiteralLength)) {

if (shouldCheckForUseStrict) {

if (directive) {

// "use strict" must be the exact literal without escape sequences or line continuation.

if (directiveLiteralLength == lengthOfUseStrictLiteral && m_vm.propertyNames->useStrictIdentifier == *directive) {

setStrictMode();

shouldCheckForUseStrict = false; // We saw "use strict", there is no need to keep checking for it.

if (!isValidStrictMode()) {

if (m_parserState.lastFunctionName) {

if (m_vm.propertyNames->arguments == *m_parserState.lastFunctionName)

semanticFail("Cannot name a function 'arguments' in strict mode");

if (m_vm.propertyNames->eval == *m_parserState.lastFunctionName)

semanticFail("Cannot name a function 'eval' in strict mode");

}

if (hasDeclaredVariable(m_vm.propertyNames->arguments))

semanticFail("Cannot declare a variable named 'arguments' in strict mode");

if (hasDeclaredVariable(m_vm.propertyNames->eval))

semanticFail("Cannot declare a variable named 'eval' in strict mode");

semanticFailIfTrue(currentScope()->hasNonSimpleParameterList(), "'use strict' directive not allowed inside a function with a non-simple parameter list");

semanticFailIfFalse(isValidStrictMode(), "Invalid parameters or function name in strict mode");

}

// Since strict mode is changed, restoring lexer state by calling next() may cause errors.

restoreSavePoint(context, savePoint);

propagateError();

continue;

}

// We saw a directive, but it wasn't "use strict". We reset our state to

// see if the next statement we parse is also a directive.

directive = nullptr;

} else {

// We saw a statement that wasn't in the form of a directive. The spec says that "use strict"

// is only allowed as the first statement, or after a sequence of directives before it, but

// not after non-directive statements.

shouldCheckForUseStrict = false;

}

}

context.appendStatement(sourceElements, statement);

}

propagateError();

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseModuleSourceElements(TreeBuilder& context)

{

TreeSourceElements sourceElements = context.createSourceElements();

SyntaxChecker syntaxChecker(const_cast<VM&>(m_vm), m_lexer.get());

while (true) {

TreeStatement statement = 0;

switch (m_token.m_type) {

case EXPORT_:

statement = parseExportDeclaration(context);

if (statement)

recordPauseLocation(context.breakpointLocation(statement));

break;

case IMPORT: {

SavePoint savePoint = createSavePoint(context);

next();

bool isImportDeclaration = !match(OPENPAREN) && !match(DOT);

restoreSavePoint(context, savePoint);

if (isImportDeclaration) {

statement = parseImportDeclaration(context);

if (statement)

recordPauseLocation(context.breakpointLocation(statement));

break;

}

// This is `import("...")` call or `import.meta` meta property case.

FALLTHROUGH;

}

default: {

const Identifier* directive = nullptr;

unsigned directiveLiteralLength = 0;

if (sourceParseMode() == SourceParseMode::ModuleAnalyzeMode) {

if (!parseStatementListItem(syntaxChecker, directive, &directiveLiteralLength))

goto end;

continue;

}

statement = parseStatementListItem(context, directive, &directiveLiteralLength);

break;

}

}

if (!statement)

goto end;

context.appendStatement(sourceElements, statement);

}

end:

propagateError();

for (const auto& pair : m_moduleScopeData->exportedBindings()) {

const auto& uid = pair.key;

if (currentScope()->hasDeclaredVariable(uid)) {

currentScope()->declaredVariables().markVariableAsExported(uid);

continue;

}

if (currentScope()->hasLexicallyDeclaredVariable(uid)) {

currentScope()->lexicalVariables().markVariableAsExported(uid);

continue;

}

semanticFail("Exported binding '", uid.get(), "' needs to refer to a top-level declared variable");

}

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseGeneratorFunctionSourceElements(TreeBuilder& context, const Identifier& name, SourceElementsMode mode)

{

auto sourceElements = context.createSourceElements();

unsigned functionKeywordStart = tokenStart();

JSTokenLocation startLocation(tokenLocation());

JSTextPosition start = tokenStartPosition();

unsigned startColumn = tokenColumn();

int functionNameStart = m_token.m_location.startOffset;

int parametersStart = m_token.m_location.startOffset;

ParserFunctionInfo<TreeBuilder> info;

info.name = &m_vm.propertyNames->nullIdentifier;

createGeneratorParameters(context, info.parameterCount);

info.startOffset = parametersStart;

info.startLine = tokenLine();

{

AutoPopScopeRef generatorBodyScope(this, pushScope());

generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode);

generatorBodyScope->setConstructorKind(ConstructorKind::None);

generatorBodyScope->setExpectedSuperBinding(m_superBinding);

SyntaxChecker generatorFunctionContext(const_cast<VM&>(m_vm), m_lexer.get());

failIfFalse(parseSourceElements(generatorFunctionContext, mode), "Cannot parse the body of a generator");

popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo);

}

info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, lexicalScopeFeatures(), ConstructorKind::None, m_superBinding, info.parameterCount, SourceParseMode::GeneratorBodyMode, false);

info.endLine = tokenLine();

info.endOffset = m_token.m_data.offset;

info.parametersStartColumn = startColumn;

auto functionExpr = context.createGeneratorFunctionBody(startLocation, info, name);

auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);

context.appendStatement(sourceElements, statement);

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseAsyncFunctionSourceElements(TreeBuilder& context, bool isArrowFunctionBodyExpression, SourceElementsMode mode)

{

ASSERT(isAsyncFunctionOrAsyncGeneratorWrapperParseMode(sourceParseMode()));

auto sourceElements = context.createSourceElements();

unsigned functionKeywordStart = tokenStart();

JSTokenLocation startLocation(tokenLocation());

JSTextPosition start = tokenStartPosition();

unsigned startColumn = tokenColumn();

int functionNameStart = m_token.m_location.startOffset;

int parametersStart = m_token.m_location.startOffset;

ParserFunctionInfo<TreeBuilder> info;

info.name = &m_vm.propertyNames->nullIdentifier;

createGeneratorParameters(context, info.parameterCount);

info.startOffset = parametersStart;

info.startLine = tokenLine();

SourceParseMode parseMode = getAsynFunctionBodyParseMode(sourceParseMode());

SetForScope innerParseMode(m_parseMode, parseMode);

{

AutoPopScopeRef asyncFunctionBodyScope(this, pushScope());

asyncFunctionBodyScope->setSourceParseMode(sourceParseMode());

SyntaxChecker syntaxChecker(const_cast<VM&>(m_vm), m_lexer.get());

if (isArrowFunctionBodyExpression) {

if (m_debuggerParseData)

failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(context), "Cannot parse the body of async arrow function");

else

failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(syntaxChecker), "Cannot parse the body of async arrow function");

} else {

if (m_debuggerParseData)

failIfFalse(parseSourceElements(context, mode), "Cannot parse the body of async function");

else

failIfFalse(parseSourceElements(syntaxChecker, mode), "Cannot parse the body of async function");

}

popScope(asyncFunctionBodyScope, TreeBuilder::NeedsFreeVariableInfo);

}

info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, lexicalScopeFeatures(), ConstructorKind::None, m_superBinding, info.parameterCount, sourceParseMode(), isArrowFunctionBodyExpression);

info.endLine = tokenLine();

info.endOffset = isArrowFunctionBodyExpression ? tokenLocation().endOffset : m_token.m_data.offset;

info.parametersStartColumn = startColumn;

auto functionExpr = context.createAsyncFunctionBody(startLocation, info, parseMode);

auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);

context.appendStatement(sourceElements, statement);

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseAsyncGeneratorFunctionSourceElements(TreeBuilder& context, bool isArrowFunctionBodyExpression, SourceElementsMode mode)

{

ASSERT(isAsyncGeneratorWrapperParseMode(sourceParseMode()));

auto sourceElements = context.createSourceElements();

unsigned functionKeywordStart = tokenStart();

JSTokenLocation startLocation(tokenLocation());

JSTextPosition start = tokenStartPosition();

unsigned startColumn = tokenColumn();

int functionNameStart = m_token.m_location.startOffset;

int parametersStart = m_token.m_location.startOffset;

ParserFunctionInfo<TreeBuilder> info;

info.name = &m_vm.propertyNames->nullIdentifier;

createGeneratorParameters(context, info.parameterCount);

info.startOffset = parametersStart;

info.startLine = tokenLine();

SourceParseMode parseMode = SourceParseMode::AsyncGeneratorBodyMode;

SetForScope innerParseMode(m_parseMode, parseMode);

{

AutoPopScopeRef asyncFunctionBodyScope(this, pushScope());

asyncFunctionBodyScope->setSourceParseMode(sourceParseMode());

SyntaxChecker syntaxChecker(const_cast<VM&>(m_vm), m_lexer.get());

if (isArrowFunctionBodyExpression) {

if (m_debuggerParseData)

failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(context), "Cannot parse the body of async arrow function");

else

failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(syntaxChecker), "Cannot parse the body of async arrow function");

} else {

if (m_debuggerParseData)

failIfFalse(parseSourceElements(context, mode), "Cannot parse the body of async function");

else

failIfFalse(parseSourceElements(syntaxChecker, mode), "Cannot parse the body of async function");

}

popScope(asyncFunctionBodyScope, TreeBuilder::NeedsFreeVariableInfo);

}

info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, lexicalScopeFeatures(), ConstructorKind::None, m_superBinding, info.parameterCount, parseMode, isArrowFunctionBodyExpression);

info.endLine = tokenLine();

info.endOffset = isArrowFunctionBodyExpression ? tokenLocation().endOffset : m_token.m_data.offset;

info.parametersStartColumn = startColumn;

auto functionExpr = context.createAsyncFunctionBody(startLocation, info, parseMode);

auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);

context.appendStatement(sourceElements, statement);

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSingleFunction(TreeBuilder& context, std::optional<int> functionConstructorParametersEndPosition)

{

TreeSourceElements sourceElements = context.createSourceElements();

TreeStatement statement = 0;

switch (m_token.m_type) {

case FUNCTION:

statement = parseFunctionDeclaration(context, FunctionDeclarationType::Declaration, ExportType::NotExported, DeclarationDefaultContext::Standard, functionConstructorParametersEndPosition);

break;

case IDENT:

if (*m_token.m_data.ident == m_vm.propertyNames->async && !m_token.m_data.escaped) {

next();

failIfFalse(match(FUNCTION) && !m_lexer->hasLineTerminatorBeforeToken(), "Cannot parse the async function");

statement = parseAsyncFunctionDeclaration(context, ExportType::NotExported, DeclarationDefaultContext::Standard, functionConstructorParametersEndPosition);

break;

}

FALLTHROUGH;

default:

failDueToUnexpectedToken();

break;

}

if (statement) {

context.setEndOffset(statement, m_lastTokenEndPosition.offset);

context.appendStatement(sourceElements, statement);

}

propagateError();

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementListItem(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)

{

// The grammar is documented here:

// http://www.ecma-international.org/ecma-262/6.0/index.html#sec-statements

DepthManager statementDepth(&m_statementDepth);

m_statementDepth++;

failIfStackOverflow();

TreeStatement result = 0;

bool shouldSetEndOffset = true;

bool shouldSetPauseLocation = false;

switch (m_token.m_type) {

case CONSTTOKEN:

result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration);

shouldSetPauseLocation = true;

break;

case LET: {

bool shouldParseVariableDeclaration = true;

if (!strictMode()) {

SavePoint savePoint = createSavePoint(context);

next();

// Intentionally use `matchIdentifierOrPossiblyEscapedContextualKeyword()` and not `matchSpecIdentifier()`.

// We would like contextual keywords to fall under parseVariableDeclaration even when not used as identifiers.

// For example, under a generator context, matchSpecIdentifier() for "yield" returns `false`.

// But we would like to enter parseVariableDeclaration and raise an error under the context of parseVariableDeclaration

// to raise consistent errors between "var", "const" and "let".

if (!matchIdentifierOrPossiblyEscapedContextualKeyword() && !match(OPENBRACE) && !match(OPENBRACKET))

shouldParseVariableDeclaration = false;

restoreSavePoint(context, savePoint);

}

if (shouldParseVariableDeclaration)

result = parseVariableDeclaration(context, DeclarationType::LetDeclaration);

else {

bool allowFunctionDeclarationAsStatement = true;

result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);

}

shouldSetPauseLocation = !context.shouldSkipPauseLocation(result);

break;

}

case CLASSTOKEN:

result = parseClassDeclaration(context);

break;

case FUNCTION:

result = parseFunctionDeclaration(context);

break;

case ESCAPED_KEYWORD:

if (!matchAllowedEscapedContextualKeyword()) {

failDueToUnexpectedToken();

break;

}

FALLTHROUGH;

case IDENT:

if (UNLIKELY(*m_token.m_data.ident == m_vm.propertyNames->async && !m_token.m_data.escaped)) {

// Eagerly parse as AsyncFunctionDeclaration. This is the uncommon case,

// but could be mistakenly parsed as an AsyncFunctionExpression.

SavePoint savePoint = createSavePoint(context);

next();

if (UNLIKELY(match(FUNCTION) && !m_lexer->hasLineTerminatorBeforeToken())) {

result = parseAsyncFunctionDeclaration(context);

break;

}

restoreSavePoint(context, savePoint);

}

FALLTHROUGH;

case AWAIT:

case YIELD: {

// This is a convenient place to notice labeled statements

// (even though we also parse them as normal statements)

// because we allow the following type of code in sloppy mode:

// ``` function foo() { label: function bar() { } } ```

bool allowFunctionDeclarationAsStatement = true;

result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);

shouldSetPauseLocation = !context.shouldSkipPauseLocation(result);

break;

}

default:

m_statementDepth--; // parseStatement() increments the depth.

result = parseStatement(context, directive, directiveLiteralLength);

shouldSetEndOffset = false;

break;

}

if (result) {

if (shouldSetEndOffset)

context.setEndOffset(result, m_lastTokenEndPosition.offset);

if (shouldSetPauseLocation)

recordPauseLocation(context.breakpointLocation(result));

}

return result;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVariableDeclaration(TreeBuilder& context, DeclarationType declarationType, ExportType exportType)

{

ASSERT(match(VAR) || match(LET) || match(CONSTTOKEN));

JSTokenLocation location(tokenLocation());

int start = tokenLine();

int end = 0;

int scratch;

TreeDestructuringPattern scratch1 = 0;

TreeExpression scratch2 = 0;

JSTextPosition scratch3;

bool scratchBool;

TreeExpression variableDecls = parseVariableDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3, VarDeclarationContext, declarationType, exportType, scratchBool);

propagateError();

failIfFalse(autoSemiColon(), "Expected ';' after variable declaration");

return context.createDeclarationStatement(location, variableDecls, start, end);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)

{

ASSERT(match(DO));

int startLine = tokenLine();

next();

const Identifier* unused = nullptr;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected a statement following 'do'");

int endLine = tokenLine();

JSTokenLocation location(tokenLocation());

handleProductionOrFail(WHILE, "while", "end", "do-while loop");

handleProductionOrFail(OPENPAREN, "(", "start", "do-while loop condition");

semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a do-while loop condition");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Unable to parse do-while loop condition");

recordPauseLocation(context.breakpointLocation(expr));

handleProductionOrFail(CLOSEPAREN, ")", "end", "do-while loop condition");

if (match(SEMICOLON))

next(); // Always performs automatic semicolon insertion.

return context.createDoWhileStatement(location, statement, expr, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)

{

ASSERT(match(WHILE));

JSTokenLocation location(tokenLocation());

int startLine = tokenLine();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "while loop condition");

semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a while loop condition");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Unable to parse while loop condition");

recordPauseLocation(context.breakpointLocation(expr));

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", "while loop condition");

const Identifier* unused = nullptr;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected a statement as the body of a while loop");

return context.createWhileStatement(location, expr, statement, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVariableDeclarationList(TreeBuilder& context, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext declarationListContext, DeclarationType declarationType, ExportType exportType, bool& forLoopConstDoesNotHaveInitializer)

{

ASSERT(declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::VarDeclaration || declarationType == DeclarationType::ConstDeclaration);

TreeExpression head = 0;

JSTokenLocation headLocation;

TreeExpression tail = 0;

const Identifier* lastIdent;

JSToken lastIdentToken;

AssignmentContext assignmentContext = assignmentContextFromDeclarationType(declarationType);

do {

lastPattern = TreeDestructuringPattern(0);

lastIdent = nullptr;

JSTokenLocation location(tokenLocation());

next();

if (head) {

// Move the location of subsequent declarations after the comma.

location = tokenLocation();

}

TreeExpression node = 0;

declarations++;

bool hasInitializer = false;

failIfTrue(match(PRIVATENAME), "Cannot use a private name to declare a variable");

if (matchSpecIdentifier()) {

failIfTrue(isPossiblyEscapedLet(m_token) && (declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::ConstDeclaration),

"Cannot use 'let' as an identifier name for a LexicalDeclaration");

semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Cannot use 'await' as a ", declarationTypeToVariableKind(declarationType), " ", disallowedIdentifierAwaitReason());

JSTextPosition varStart = tokenStartPosition();

JSTokenLocation varStartLocation(tokenLocation());

identStart = varStart;

const Identifier* name = m_token.m_data.ident;

lastIdent = name;

lastIdentToken = m_token;

next();

hasInitializer = match(EQUAL);

DeclarationResultMask declarationResult = declareVariable(name, declarationType);

if (declarationResult != DeclarationResult::Valid) {

failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a variable named ", name->impl(), " in strict mode");

if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) {

if (declarationType == DeclarationType::LetDeclaration)

internalFailWithMessage(false, "Cannot declare a let variable twice: '", name->impl(), "'");

if (declarationType == DeclarationType::ConstDeclaration)

internalFailWithMessage(false, "Cannot declare a const variable twice: '", name->impl(), "'");

ASSERT(declarationType == DeclarationType::VarDeclaration);

internalFailWithMessage(false, "Cannot declare a var variable that shadows a let/const/class variable: '", name->impl(), "'");

}

}

if (exportType == ExportType::Exported) {

semanticFailIfFalse(exportName(*name), "Cannot export a duplicate name '", name->impl(), "'");

m_moduleScopeData->exportBinding(*name);

}

if (hasInitializer) {

JSTextPosition varDivot = tokenStartPosition() + 1;

initStart = tokenStartPosition();

next(TreeBuilder::DontBuildStrings); // consume '='

propagateError();

TreeExpression initializer = parseAssignmentExpression(context);

initEnd = lastTokenEndPosition();

lastInitializer = initializer;

failIfFalse(initializer, "Expected expression as the intializer for the variable '", name->impl(), "'");

node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition(), assignmentContext);

} else {

if (declarationListContext == ForLoopContext && declarationType == DeclarationType::ConstDeclaration)

forLoopConstDoesNotHaveInitializer = true;

failIfTrue(declarationListContext != ForLoopContext && declarationType == DeclarationType::ConstDeclaration, "const declared variable '", name->impl(), "'", " must have an initializer");

if (declarationType == DeclarationType::VarDeclaration)

node = context.createEmptyVarExpression(varStartLocation, *name);

else

node = context.createEmptyLetExpression(varStartLocation, *name);

}

} else {

lastIdent = nullptr;

auto pattern = parseDestructuringPattern(context, destructuringKindFromDeclarationType(declarationType), exportType, nullptr, nullptr, assignmentContext);

failIfFalse(pattern, "Cannot parse this destructuring pattern");

hasInitializer = match(EQUAL);

failIfTrue(declarationListContext == VarDeclarationContext && !hasInitializer, "Expected an initializer in destructuring variable declaration");

lastPattern = pattern;

if (hasInitializer) {

next(TreeBuilder::DontBuildStrings); // consume '='

TreeExpression rhs = parseAssignmentExpression(context);

propagateError();

ASSERT(rhs);

node = context.createDestructuringAssignment(location, pattern, rhs);

lastInitializer = rhs;

}

}

if (node) {

if (!head) {

head = node;

headLocation = location;

} else {

if (!tail) {

head = tail = context.createCommaExpr(headLocation, head);

recordPauseLocation(context.breakpointLocation(head));

}

tail = context.appendToCommaExpr(location, head, tail, node);

recordPauseLocation(context.breakpointLocation(tail));

}

}

} while (match(COMMA));

if (lastIdent)

lastPattern = context.createBindingLocation(lastIdentToken.m_location, *lastIdent, lastIdentToken.m_startPosition, lastIdentToken.m_endPosition, assignmentContext);

return head;

}

template <typename LexerType>

bool Parser<LexerType>::declareRestOrNormalParameter(const Identifier& name, const Identifier** duplicateIdentifier)

{

DeclarationResultMask declarationResult = declareParameter(&name);

if ((declarationResult & DeclarationResult::InvalidStrictMode) && strictMode()) {

semanticFailIfTrue(isEvalOrArguments(&name), "Cannot destructure to a parameter name '", name.impl(), "' in strict mode");

if (m_parserState.lastFunctionName && name == *m_parserState.lastFunctionName)

semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");

semanticFailureDueToKeyword("parameter name");

if (!m_lexer->isReparsingFunction() && hasDeclaredParameter(name))

semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode as it has already been declared");

semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode");

}

if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) {

// It's not always an error to define a duplicate parameter.

// It's only an error when there are default parameter values or destructuring parameters.

// We note this value now so we can check it later.

if (duplicateIdentifier)

*duplicateIdentifier = &name;

}

return true;

}

template <typename LexerType>

template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier& name, const JSToken& token, AssignmentContext bindingContext, const Identifier** duplicateIdentifier)

{

ASSERT(!name.isNull());

ASSERT(name.impl()->isAtom() || name.impl()->isSymbol());