/*

* Copyright (c) Facebook, Inc. and its affiliates.

*

* This source code is licensed under the MIT license found in the

* LICENSE file in the root directory of this source tree.

*/

#include "JSParserImpl.h"

#include "hermes/AST/ESTreeJSONDumper.h"

#include "hermes/Support/PerfSection.h"

#include "llvh/Support/SaveAndRestore.h"

using llvh::cast;

using llvh::dyn_cast;

using llvh::isa;

namespace hermes {

namespace parser {

namespace detail {

/// Declare a RAII recursion tracker. Check whether the recursion limit has

/// been exceeded, and if so generate an error and return an empty

/// llvh::Optional<>.

#define CHECK_RECURSION \

TrackRecursion trackRecursion{this}; \

if (recursionDepthCheck()) \

return llvh::None;

JSParserImpl::JSParserImpl(

Context &context,

std::unique_ptr<llvh::MemoryBuffer> input)

: context_(context),

sm_(context.getSourceErrorManager()),

lexer_(

std::move(input),

context.getSourceErrorManager(),

context.getAllocator(),

&context.getStringTable(),

context.isStrictMode()),

pass_(FullParse) {

initializeIdentifiers();

}

JSParserImpl::JSParserImpl(Context &context, uint32_t bufferId, ParserPass pass)

: context_(context),

sm_(context.getSourceErrorManager()),

lexer_(

bufferId,

context.getSourceErrorManager(),

context.getAllocator(),

&context.getStringTable(),

context.isStrictMode()),

pass_(pass) {

preParsed_ = context.getPreParsedBufferInfo(bufferId);

initializeIdentifiers();

}

void JSParserImpl::initializeIdentifiers() {

getIdent_ = lexer_.getIdentifier("get");

setIdent_ = lexer_.getIdentifier("set");

initIdent_ = lexer_.getIdentifier("init");

useStrictIdent_ = lexer_.getIdentifier("use strict");

letIdent_ = lexer_.getIdentifier("let");

ofIdent_ = lexer_.getIdentifier("of");

useStaticBuiltinIdent_ = lexer_.getIdentifier("use static builtin");

fromIdent_ = lexer_.getIdentifier("from");

asIdent_ = lexer_.getIdentifier("as");

implementsIdent_ = lexer_.getIdentifier("implements");

interfaceIdent_ = lexer_.getIdentifier("interface");

packageIdent_ = lexer_.getIdentifier("package");

privateIdent_ = lexer_.getIdentifier("private");

protectedIdent_ = lexer_.getIdentifier("protected");

publicIdent_ = lexer_.getIdentifier("public");

staticIdent_ = lexer_.getIdentifier("static");

methodIdent_ = lexer_.getIdentifier("method");

constructorIdent_ = lexer_.getIdentifier("constructor");

yieldIdent_ = lexer_.getIdentifier("yield");

newIdent_ = lexer_.getIdentifier("new");

targetIdent_ = lexer_.getIdentifier("target");

valueIdent_ = lexer_.getIdentifier("value");

typeIdent_ = lexer_.getIdentifier("type");

asyncIdent_ = lexer_.getIdentifier("async");

awaitIdent_ = lexer_.getIdentifier("await");

#if HERMES_PARSE_FLOW

typeofIdent_ = lexer_.getIdentifier("typeof");

declareIdent_ = lexer_.getIdentifier("declare");

opaqueIdent_ = lexer_.getIdentifier("opaque");

plusIdent_ = lexer_.getIdentifier("plus");

minusIdent_ = lexer_.getIdentifier("minus");

moduleIdent_ = lexer_.getIdentifier("module");

exportsIdent_ = lexer_.getIdentifier("exports");

esIdent_ = lexer_.getIdentifier("ES");

commonJSIdent_ = lexer_.getIdentifier("CommonJS");

anyIdent_ = lexer_.getIdentifier("any");

mixedIdent_ = lexer_.getIdentifier("mixed");

emptyIdent_ = lexer_.getIdentifier("empty");

booleanIdent_ = lexer_.getIdentifier("boolean");

numberIdent_ = lexer_.getIdentifier("number");

stringIdent_ = lexer_.getIdentifier("string");

voidIdent_ = lexer_.getIdentifier("void");

nullIdent_ = lexer_.getIdentifier("null");

symbolIdent_ = lexer_.getIdentifier("symbol");

checksIdent_ = lexer_.getIdentifier("%checks");

#endif

// Generate the string representation of all tokens.

for (unsigned i = 0; i != NUM_JS_TOKENS; ++i)

tokenIdent_[i] = lexer_.getIdentifier(tokenKindStr((TokenKind)i));

}

Optional<ESTree::ProgramNode *> JSParserImpl::parse() {

PerfSection parsing("Parsing JavaScript");

tok_ = lexer_.advance();

auto res = parseProgram();

if (!res)

return None;

if (lexer_.getSourceMgr().getErrorCount() != 0)

return None;

return res.getValue();

}

void JSParserImpl::errorExpected(

ArrayRef<TokenKind> toks,

const char *where,

const char *what,

SMLoc whatLoc) {

llvh::SmallString<4> str;

llvh::raw_svector_ostream ss{str};

for (unsigned i = 0; i < toks.size(); ++i) {

// Insert a separator after the first token.

if (i > 0) {

// Use " or " instead of ", " before the last token.

if (i == toks.size() - 1)

ss << " or ";

else

ss << ", ";

}

ss << "'" << tokenKindStr(toks[i]) << "'";

}

ss << " expected";

// Optionally append the 'where' description.

if (where)

ss << " " << where;

SMLoc errorLoc = tok_->getStartLoc();

SourceErrorManager::SourceCoords curCoords;

SourceErrorManager::SourceCoords whatCoords;

// If the location of 'what' is provided, find its and the error's source

// coordinates.

if (whatLoc.isValid()) {

sm_.findBufferLineAndLoc(errorLoc, curCoords);

sm_.findBufferLineAndLoc(whatLoc, whatCoords);

}

if (whatCoords.isSameSourceLineAs(curCoords)) {

// If the what source coordinates are on the same line as the error, show

// them both.

sm_.error(

errorLoc,

SourceErrorManager::combineIntoRange(whatLoc, errorLoc),

ss.str(),

Subsystem::Parser);

} else {

sm_.error(errorLoc, ss.str(), Subsystem::Parser);

if (what && whatCoords.isValid())

sm_.note(whatLoc, what, Subsystem::Parser);

}

}

bool JSParserImpl::need(

TokenKind kind,

const char *where,

const char *what,

SMLoc whatLoc) {

if (tok_->getKind() == kind) {

return true;

}

errorExpected(kind, where, what, whatLoc);

return false;

}

bool JSParserImpl::eat(

TokenKind kind,

JSLexer::GrammarContext grammarContext,

const char *where,

const char *what,

SMLoc whatLoc) {

if (need(kind, where, what, whatLoc)) {

advance(grammarContext);

return true;

}

return false;

}

bool JSParserImpl::checkAndEat(

TokenKind kind,

JSLexer::GrammarContext grammarContext) {

if (tok_->getKind() == kind) {

advance(grammarContext);

return true;

}

return false;

}

bool JSParserImpl::checkAndEat(

UniqueString *ident,

JSLexer::GrammarContext grammarContext) {

if (check(ident)) {

advance(grammarContext);

return true;

}

return false;

}

bool JSParserImpl::checkAssign() const {

return checkN(

TokenKind::equal,

TokenKind::starequal,

TokenKind::slashequal,

TokenKind::percentequal,

TokenKind::plusequal,

TokenKind::minusequal,

TokenKind::lesslessequal,

TokenKind::greatergreaterequal,

TokenKind::greatergreatergreaterequal,

TokenKind::starstarequal,

TokenKind::pipepipeequal,

TokenKind::ampampequal,

TokenKind::questionquestionequal,

TokenKind::ampequal,

TokenKind::caretequal,

TokenKind::pipeequal);

}

bool JSParserImpl::checkEndAssignmentExpression() const {

return checkN(

TokenKind::rw_in,

ofIdent_,

TokenKind::r_paren,

TokenKind::r_brace,

TokenKind::r_square,

TokenKind::comma,

TokenKind::semi,

TokenKind::colon,

TokenKind::eof) ||

lexer_.isNewLineBeforeCurrentToken();

}

bool JSParserImpl::checkAsyncFunction() {

// async [no LineTerminator here] function

// ^

assert(

check(asyncIdent_) && "check for async function must occur at 'async'");

// Avoid passing TokenKind::rw_function here, because parseFunctionHelper

// relies on seeing `async` in order to construct its AST node.

// This function must also be idempotent to allow for branching based on its

// result in parseStatementListItem without having to store another flag,

// for example.

OptValue<TokenKind> optNext = lexer_.lookahead1(llvh::None);

return optNext.hasValue() && *optNext == TokenKind::rw_function;

}

bool JSParserImpl::eatSemi(SMLoc &endLoc, bool optional) {

if (tok_->getKind() == TokenKind::semi) {

endLoc = tok_->getEndLoc();

advance();

return true;

}

if (tok_->getKind() == TokenKind::r_brace ||

tok_->getKind() == TokenKind::eof ||

lexer_.isNewLineBeforeCurrentToken()) {

return true;

}

if (!optional)

error(tok_->getStartLoc(), "';' expected");

return false;

}

void JSParserImpl::processDirective(UniqueString *directive) {

if (directive == useStrictIdent_)

setStrictMode(true);

if (directive == useStaticBuiltinIdent_)

setUseStaticBuiltin();

}

bool JSParserImpl::recursionDepthExceeded() {

assert(

recursionDepth_ >= MAX_RECURSION_DEPTH &&

"recursionDepthExceeded called without recursionDepthCheck");

error(

tok_->getStartLoc(),

"Too many nested expressions/statements/declarations");

return true;

}

Optional<ESTree::ProgramNode *> JSParserImpl::parseProgram() {

SMLoc startLoc = tok_->getStartLoc();

SaveStrictMode saveStrict{this};

ESTree::NodeList stmtList;

if (!parseStatementList(

Param{}, TokenKind::eof, true, AllowImportExport::Yes, stmtList))

return None;

SMLoc endLoc = startLoc;

if (!stmtList.empty()) {

endLoc = stmtList.back().getEndLoc();

}

auto *program = setLocation(

startLoc,

endLoc,

new (context_) ESTree::ProgramNode(std::move(stmtList)));

program->strictness = ESTree::makeStrictness(isStrictMode());

return program;

}

Optional<ESTree::FunctionDeclarationNode *>

JSParserImpl::parseFunctionDeclaration(Param param, bool forceEagerly) {

auto optRes = parseFunctionHelper(param, true, forceEagerly);

if (!optRes)

return None;

return cast<ESTree::FunctionDeclarationNode>(*optRes);

}

Optional<ESTree::FunctionLikeNode *> JSParserImpl::parseFunctionHelper(

Param param,

bool isDeclaration,

bool forceEagerly) {

// function or async function

assert(check(TokenKind::rw_function) || check(asyncIdent_));

bool isAsync = check(asyncIdent_);

SMLoc startLoc = advance().Start;

if (isAsync) {

// async function

// ^

advance();

}

bool isGenerator = checkAndEat(TokenKind::star);

// newParamYield setting per the grammar:

// FunctionDeclaration: BindingIdentifier[?Yield, ?Await]

// FunctionExpression: BindingIdentifier[~Yield, ~Await]

// GeneratorFunctionDeclaration: BindingIdentifier[?Yield, ?Await]

// GeneratorFunctionExpression: BindingIdentifier[+Yield, ~Await]

// AsyncFunctionDeclaration: BindingIdentifier[?Yield, ?Await]

// AsyncFunctionExpression: BindingIdentifier[+Yield, +Await]

// AsyncGeneratorDeclaration: BindingIdentifier[?Yield, ?Await]

// AsyncGeneratorExpression: BindingIdentifier[+Yield, +Await]

bool nameParamYield = isDeclaration ? paramYield_ : isGenerator;

llvh::SaveAndRestore<bool> saveNameParamYield(paramYield_, nameParamYield);

bool nameParamAwait = isDeclaration ? paramAwait_ : isAsync;

llvh::SaveAndRestore<bool> saveNameParamAwait(paramAwait_, nameParamAwait);

// identifier

auto optId = parseBindingIdentifier(Param{});

// If this is a default function declaration, then we can match

// [+Default] function ( FormalParameters ) { FunctionBody }

// so the identifier is optional and we can make it nullptr.

if (isDeclaration && !param.has(ParamDefault) && !optId) {

errorExpected(

TokenKind::identifier,

"after 'function'",

"location of 'function'",

startLoc);

return None;

}

ESTree::Node *typeParams = nullptr;

#if HERMES_PARSE_FLOW

if (context_.getParseFlow() && check(TokenKind::less)) {

auto optTypeParams = parseTypeParams();

if (!optTypeParams)

return None;

typeParams = *optTypeParams;

}

#endif

// (

if (!need(

TokenKind::l_paren,

"at start of function parameter list",

isDeclaration ? "function declaration starts here"

: "function expression starts here",

startLoc)) {

return None;

}

ESTree::NodeList paramList;

llvh::SaveAndRestore<bool> saveArgsAndBodyParamYield(

paramYield_, isGenerator);

llvh::SaveAndRestore<bool> saveArgsAndBodyParamAwait(paramAwait_, isAsync);

if (!parseFormalParameters(param, paramList))

return None;

ESTree::Node *returnType = nullptr;

ESTree::Node *predicate = nullptr;

#if HERMES_PARSE_FLOW

if (context_.getParseFlow() &&

checkAndEat(TokenKind::colon, JSLexer::GrammarContext::Flow)) {

if (!check(checksIdent_)) {

auto optRet = parseTypeAnnotation(true);

if (!optRet)

return None;

returnType = *optRet;

}

if (check(checksIdent_)) {

auto optPred = parsePredicate();

if (!optPred)

return None;

predicate = *optPred;

}

}

#endif

// {

if (!need(

TokenKind::l_brace,

isDeclaration ? "in function declaration" : "in function expression",

isDeclaration ? "start of function declaration"

: "start of function expression",

startLoc)) {

return None;

}

SaveStrictMode saveStrictMode{this};

// Grammar context to be used when lexing the closing brace.

auto grammarContext =

isDeclaration ? JSLexer::AllowRegExp : JSLexer::AllowDiv;

if (pass_ == PreParse) {

// Create the nodes we want to keep before the AllocationScope.

ESTree::FunctionLikeNode *node;

if (isDeclaration) {

auto *decl = new (context_) ESTree::FunctionDeclarationNode(

optId ? *optId : nullptr,

std::move(paramList),

nullptr,

typeParams,

returnType,

predicate,

isGenerator,

isAsync);

// Initialize the node with a blank body.

decl->_body = new (context_) ESTree::BlockStatementNode({});

node = decl;

} else {

auto *expr = new (context_) ESTree::FunctionExpressionNode(

optId ? *optId : nullptr,

std::move(paramList),

nullptr,

typeParams,

returnType,

predicate,

isGenerator,

isAsync);

// Initialize the node with a blank body.

expr->_body = new (context_) ESTree::BlockStatementNode({});

node = expr;

}

AllocationScope scope(context_.getAllocator());

auto body = parseFunctionBody(Param{}, false, grammarContext, true);

if (!body)

return None;

node->strictness = ESTree::makeStrictness(isStrictMode());

return setLocation(startLoc, body.getValue(), node);

}

auto parsedBody =

parseFunctionBody(Param{}, forceEagerly, grammarContext, true);

if (!parsedBody)

return None;

auto *body = parsedBody.getValue();

ESTree::FunctionLikeNode *node;

if (isDeclaration) {

auto *decl = new (context_) ESTree::FunctionDeclarationNode(

optId ? *optId : nullptr,

std::move(paramList),

body,

typeParams,

returnType,

predicate,

isGenerator,

isAsync);

decl->strictness = ESTree::makeStrictness(isStrictMode());

node = decl;

} else {

auto *expr = new (context_) ESTree::FunctionExpressionNode(

optId ? *optId : nullptr,

std::move(paramList),

body,

typeParams,

returnType,

predicate,

isGenerator,

isAsync);

expr->strictness = ESTree::makeStrictness(isStrictMode());

node = expr;

}

return setLocation(startLoc, body, node);

}

bool JSParserImpl::parseFormalParameters(

Param param,

ESTree::NodeList &paramList) {

assert(check(TokenKind::l_paren) && "FormalParameters must start with '('");

// (

SMLoc lparenLoc = advance().Start;

while (!check(TokenKind::r_paren)) {

if (check(TokenKind::dotdotdot)) {

// BindingRestElement.

auto optRestElem = parseBindingRestElement(param);

if (!optRestElem)

return false;

paramList.push_back(*optRestElem.getValue());

break;

}

// BindingElement.

auto optElem = parseBindingElement(param);

if (!optElem)

return false;

paramList.push_back(*optElem.getValue());

if (!checkAndEat(TokenKind::comma))

break;

}

// )

if (!eat(

TokenKind::r_paren,

JSLexer::AllowRegExp,

"at end of function parameter list",

"start of parameter list",

lparenLoc)) {

return false;

}

return true;

}

Optional<ESTree::Node *> JSParserImpl::parseStatement(Param param) {

CHECK_RECURSION;

#define _RET(parseFunc) \

if (auto res = (parseFunc)) \

return res.getValue(); \

else \

return None;

switch (tok_->getKind()) {

case TokenKind::l_brace:

_RET(parseBlock(param));

case TokenKind::rw_var:

_RET(parseVariableStatement(Param{}));

case TokenKind::semi:

_RET(parseEmptyStatement());

case TokenKind::rw_if:

_RET(parseIfStatement(param.get(ParamReturn)));

case TokenKind::rw_while:

_RET(parseWhileStatement(param.get(ParamReturn)));

case TokenKind::rw_do:

_RET(parseDoWhileStatement(param.get(ParamReturn)));

case TokenKind::rw_for:

_RET(parseForStatement(param.get(ParamReturn)));

case TokenKind::rw_continue:

_RET(parseContinueStatement());

case TokenKind::rw_break:

_RET(parseBreakStatement());

case TokenKind::rw_return:

_RET(parseReturnStatement());

case TokenKind::rw_with:

_RET(parseWithStatement(param.get(ParamReturn)));

case TokenKind::rw_switch:

_RET(parseSwitchStatement(param.get(ParamReturn)));

case TokenKind::rw_throw:

_RET(parseThrowStatement(Param{}));

case TokenKind::rw_try:

_RET(parseTryStatement(param.get(ParamReturn)));

case TokenKind::rw_debugger:

_RET(parseDebuggerStatement());

default:

_RET(parseExpressionOrLabelledStatement(param.get(ParamReturn)));

}

#undef _RET

}

Optional<ESTree::BlockStatementNode *> JSParserImpl::parseFunctionBody(

Param param,

bool eagerly,

JSLexer::GrammarContext grammarContext,

bool parseDirectives) {

if (pass_ == LazyParse && !eagerly) {

auto startLoc = tok_->getStartLoc();

assert(preParsed_->bodyStartToEnd.count(startLoc) == 1);

auto endLoc = preParsed_->bodyStartToEnd[startLoc];

if ((unsigned)(endLoc.getPointer() - startLoc.getPointer()) >=

context_.getPreemptiveFunctionCompilationThreshold()) {

lexer_.seek(endLoc);

advance();

auto *body = new (context_) ESTree::BlockStatementNode({});

body->isLazyFunctionBody = true;

body->bufferId = lexer_.getBufferId();

return setLocation(startLoc, endLoc, body);

}

}

auto body = parseBlock(ParamReturn, grammarContext, parseDirectives);

if (!body)

return None;

if (pass_ == PreParse) {

preParsed_->bodyStartToEnd[(*body)->getStartLoc()] = (*body)->getEndLoc();

}

return body;

}

Optional<ESTree::Node *> JSParserImpl::parseDeclaration(Param param) {

CHECK_RECURSION;

assert(checkDeclaration() && "invalid start for declaration");

if (check(TokenKind::rw_function) || check(asyncIdent_)) {

auto fdecl = parseFunctionDeclaration(Param{});

if (!fdecl)

return None;

return *fdecl;

}

if (check(TokenKind::rw_class)) {

auto optClass = parseClassDeclaration(Param{});

if (!optClass)

return None;

return *optClass;

}

if (checkN(TokenKind::rw_const, letIdent_)) {

auto optLexDecl = parseLexicalDeclaration(ParamIn);

if (!optLexDecl)

return None;

return *optLexDecl;

}

#if HERMES_PARSE_FLOW

if (context_.getParseFlow()) {

auto optDecl = parseFlowDeclaration();

if (!optDecl)

return None;

return *optDecl;

}

#endif

assert(false && "checkDeclaration() returned true without a declaration");

return None;

}

bool JSParserImpl::parseStatementListItem(

Param param,

bool parseDirectives,

AllowImportExport allowImportExport,

ESTree::NodeList &stmtList) {

if (checkDeclaration()) {

auto decl = parseDeclaration(Param{});

if (!decl)

return false;

stmtList.push_back(*decl.getValue());

#if HERMES_PARSE_FLOW

} else if (context_.getParseFlow() && checkDeclareType()) {

// declare var, declare function, declare interface, etc.

SMLoc start = advance(JSLexer::GrammarContext::Flow).Start;

auto decl = parseDeclare(start);

if (!decl)

return false;

stmtList.push_back(*decl.getValue());

#endif

} else if (tok_->getKind() == TokenKind::rw_import) {

// 'import' can indicate an import declaration, but it's also possible a

// Statement begins with a call to `import()`, so do a lookahead to see if

// the next token is '('.

auto optNext = lexer_.lookahead1(None);

if (optNext.hasValue() && *optNext == TokenKind::l_paren) {

auto stmt = parseStatement(param.get(ParamReturn));

if (!stmt)

return false;

stmtList.push_back(*stmt.getValue());

} else {

auto importDecl = parseImportDeclaration();

if (!importDecl) {

return false;

}

stmtList.push_back(*importDecl.getValue());

if (allowImportExport == AllowImportExport::No) {

error(

importDecl.getValue()->getSourceRange(),

"import declaration must be at top level of module");

}

}

} else if (tok_->getKind() == TokenKind::rw_export) {

auto exportDecl = parseExportDeclaration();

if (!exportDecl) {

return false;

}

if (allowImportExport == AllowImportExport::Yes) {

stmtList.push_back(**exportDecl);

} else {

error(

exportDecl.getValue()->getSourceRange(),

"export declaration must be at top level of module");

}

} else {

auto stmt = parseStatement(param.get(ParamReturn));

if (!stmt)

return false;

stmtList.push_back(*stmt.getValue());

}

return true;

}

template <typename... Tail>

Optional<bool> JSParserImpl::parseStatementList(

Param param,

TokenKind until,

bool parseDirectives,

AllowImportExport allowImportExport,

ESTree::NodeList &stmtList,

Tail... otherUntil) {

if (parseDirectives) {

ESTree::ExpressionStatementNode *dirStmt;

while (check(TokenKind::string_literal) &&

(dirStmt = parseDirective()) != nullptr) {

stmtList.push_back(*dirStmt);

}

}

while (!check(TokenKind::eof) && !checkN(until, otherUntil...)) {

if (!parseStatementListItem(

param, parseDirectives, allowImportExport, stmtList)) {

return None;

}

}

return true;

}

Optional<ESTree::BlockStatementNode *> JSParserImpl::parseBlock(

Param param,

JSLexer::GrammarContext grammarContext,

bool parseDirectives) {

// {

assert(check(TokenKind::l_brace));

SMLoc startLoc = advance().Start;

ESTree::NodeList stmtList;

if (!parseStatementList(

param,

TokenKind::r_brace,

parseDirectives,

AllowImportExport::No,

stmtList)) {

return None;

}

// }

auto *body = setLocation(

startLoc,

tok_,

new (context_) ESTree::BlockStatementNode(std::move(stmtList)));

if (!eat(

TokenKind::r_brace,

grammarContext,

"at end of block",

"block starts here",

startLoc))

return None;

return body;

}

bool JSParserImpl::validateBindingIdentifier(

Param param,

SMRange range,

UniqueString *id,

TokenKind kind) {

if (id == yieldIdent_) {

// yield is permitted as BindingIdentifier in the grammar,

// and prohibited with static semantics.

if (isStrictMode() || paramYield_) {

error(range, "Unexpected usage of 'yield' as an identifier");

}

}

if (id == awaitIdent_) {

// await is permitted as BindingIdentifier in the grammar,

// and prohibited with static semantics.

if (paramAwait_) {

error(range, "Unexpected usage of 'await' as an identifier");

}

}

if (isStrictMode() && id == letIdent_) {

// ES9.0 12.1.1

// BindingIdentifier : Identifier

// Identifier : IdentifierName (but not ReservedWord)

// It is a Syntax Error if this phrase is contained in strict mode code

// and the StringValue of IdentifierName is: "implements", "interface",

// "let", "package", "private", "protected", "public", "static", or

// "yield".

// NOTE: All except 'let' are scanned as reserved words instead of

// identifiers, so we only check for `let` here.

error(

range,

"Invalid use of strict mode reserved word as binding identifier");

}

return kind == TokenKind::identifier || kind == TokenKind::rw_yield;

}

Optional<ESTree::IdentifierNode *> JSParserImpl::parseBindingIdentifier(

Param param) {

if (!check(TokenKind::identifier) && !tok_->isResWord()) {

return None;

}

SMRange identRng = tok_->getSourceRange();

// If we have an identifier or reserved word, then store it and the kind,

// and pass it to the validateBindingIdentifier function.

UniqueString *id = tok_->getResWordOrIdentifier();

TokenKind kind = tok_->getKind();

if (!validateBindingIdentifier(param, tok_->getSourceRange(), id, kind)) {

return None;

}

advance();

ESTree::Node *type = nullptr;

#if HERMES_PARSE_FLOW

if (context_.getParseFlow()) {

if (checkAndEat(TokenKind::question)) {

// TODO: Store `optional` to the IdentifierNode.

}

if (checkAndEat(TokenKind::colon, JSLexer::GrammarContext::Flow)) {

auto optType = parseTypeAnnotation(true);

if (!optType)

return None;

type = *optType;

}

}

#endif

return setLocation(

identRng,

type ? type->getSourceRange() : identRng,

new (context_) ESTree::IdentifierNode(id, type));

}

Optional<ESTree::VariableDeclarationNode *>

JSParserImpl::parseLexicalDeclaration(Param param) {

assert(

(check(TokenKind::rw_var) || check(TokenKind::rw_const) ||

check(letIdent_)) &&

"parseLexicalDeclaration() expects var/const/let");

bool isConst = check(TokenKind::rw_const);

auto kindIdent = tok_->getResWordOrIdentifier();

SMLoc startLoc = advance().Start;

ESTree::NodeList declList;

if (!parseVariableDeclarationList(param, declList, startLoc))

return None;

auto endLoc = declList.back().getEndLoc();

if (!eatSemi(endLoc))

return None;

if (isConst) {

for (const ESTree::Node &decl : declList) {

const auto *varDecl = cast<ESTree::VariableDeclaratorNode>(&decl);

if (!varDecl->_init) {

// ES9.0 13.3.1.1

// LexicalBinding : BindingIdentifier Initializer

// It is a Syntax Error if Initializer is not present and

// IsConstantDeclaration of the LexicalDeclaration containing this

// LexicalBinding is true.

// Note that we don't perform this check in the SemanticValidator

// because `const` declarations in `for` loops don't need initializers.

error(

varDecl->getSourceRange(),

"missing initializer in const declaration");

}

}

}

auto *res = setLocation(

startLoc,

endLoc,

new (context_)

ESTree::VariableDeclarationNode(kindIdent, std::move(declList)));

ensureDestructuringInitialized(res);

return res;

}

Optional<ESTree::VariableDeclarationNode *>

JSParserImpl::parseVariableStatement(Param param) {

return parseLexicalDeclaration(ParamIn);

}

Optional<const char *> JSParserImpl::parseVariableDeclarationList(

Param param,

ESTree::NodeList &declList,

SMLoc declLoc) {

do {

auto optDecl = parseVariableDeclaration(param, declLoc);

if (!optDecl)

return None;

declList.push_back(*optDecl.getValue());

} while (checkAndEat(TokenKind::comma));

return "OK";

}

void JSParserImpl::ensureDestructuringInitialized(

ESTree::VariableDeclarationNode *declNode) {

for (auto &elem : declNode->_declarations) {

auto *declarator = cast<ESTree::VariableDeclaratorNode>(&elem);

if (!isa<ESTree::PatternNode>(declarator->_id) || declarator->_init)

continue;

error(

declarator->_id->getSourceRange(),

"destucturing declaration must be initialized");

}

}

Optional<ESTree::VariableDeclaratorNode *>

JSParserImpl::parseVariableDeclaration(Param param, SMLoc declLoc) {

ESTree::Node *target;

if (check(TokenKind::l_square, TokenKind::l_brace)) {

auto optPat = parseBindingPattern(param);

if (!optPat)

return None;

target = *optPat;

} else {

auto optIdent = parseBindingIdentifier(Param{});

if (!optIdent) {

errorExpected(

TokenKind::identifier,

"in declaration",

"declaration started here",

declLoc);

return None;

}

target = *optIdent;

}

// No initializer?