☠☠ backed out by ac148c181d2b ☠ ☠ | |
author | David Teller <dteller@mozilla.com> |
Thu, 05 Apr 2018 14:31:40 +0200 | |
changeset 414042 | 8bdeab80ff08949d236fd898a669e44b93f9ce30 |
parent 414041 | 7eb7f7be58f04234484ef5f4cf7ea7adab13ace1 |
child 414043 | f69489d9bb15211206456e1829a42dada55bec2c |
push id | 33857 |
push user | ncsoregi@mozilla.com |
push date | Tue, 17 Apr 2018 21:54:38 +0000 |
treeherder | mozilla-central@1a1223d74b7b [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | arai, efaust |
bugs | 1439855 |
milestone | 61.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- a/js/src/frontend/BinSource-auto.cpp +++ b/js/src/frontend/BinSource-auto.cpp @@ -11,18 +11,18 @@ #include "mozilla/ArrayUtils.h" #include "mozilla/Casting.h" #include "mozilla/Maybe.h" #include "mozilla/Move.h" #include "mozilla/PodOperations.h" #include "mozilla/Vector.h" +#include "frontend/BinSource-macros.h" #include "frontend/BinSource.h" -#include "frontend/BinSource-macros.h" #include "frontend/BinTokenReaderTester.h" #include "frontend/FullParseHandler.h" #include "frontend/Parser.h" #include "frontend/SharedContext.h" #include "vm/RegExpObject.h" #include "frontend/ParseContext-inl.h" @@ -50,17 +50,17 @@ BinASTParser<Tok>::parseArrowExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumArrowExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumArrowExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumArrowExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -90,17 +90,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { @@ -140,17 +140,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumAssignmentTargetOrAssignmentTargetWithInitializer(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumAssignmentTargetOrAssignmentTargetWithInitializer(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields) { @@ -189,17 +189,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumAssignmentTargetPattern(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumAssignmentTargetPattern(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields) { @@ -226,17 +226,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumAssignmentTargetProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumAssignmentTargetProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields) { @@ -264,17 +264,17 @@ BinASTParser<Tok>::parseBinding() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumBinding(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumBinding(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields) { @@ -306,17 +306,17 @@ BinASTParser<Tok>::parseBindingOrBinding { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumBindingOrBindingWithInitializer(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumBindingOrBindingWithInitializer(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields) { @@ -349,17 +349,17 @@ BinASTParser<Tok>::parseBindingPattern() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumBindingPattern(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumBindingPattern(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields) { @@ -386,17 +386,17 @@ BinASTParser<Tok>::parseBindingProperty( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumBindingProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumBindingProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields) { @@ -426,17 +426,17 @@ BinASTParser<Tok>::parseExportDeclaratio { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumExportDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumExportDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -500,17 +500,17 @@ BinASTParser<Tok>::parseExpression() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -650,17 +650,17 @@ BinASTParser<Tok>::parseExpressionOrSupe { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumExpressionOrSuper(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumExpressionOrSuper(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields) { @@ -803,17 +803,17 @@ BinASTParser<Tok>::parseExpressionOrTemp { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumExpressionOrTemplateElement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumExpressionOrTemplateElement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -931,17 +931,17 @@ BinASTParser<Tok>::parseForInOfBindingOr { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumForInOfBindingOrAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumForInOfBindingOrAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1009,17 +1009,17 @@ BinASTParser<Tok>::parseFunctionBodyOrEx { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumFunctionBodyOrExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumFunctionBodyOrExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1133,17 +1133,17 @@ BinASTParser<Tok>::parseFunctionDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumFunctionDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumFunctionDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1201,17 +1201,17 @@ BinASTParser<Tok>::parseFunctionDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1333,17 +1333,17 @@ BinASTParser<Tok>::parseFunctionDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1376,17 +1376,17 @@ BinASTParser<Tok>::parseFunctionExpressi { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumFunctionExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumFunctionExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1413,17 +1413,17 @@ BinASTParser<Tok>::parseGetter() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumGetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumGetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumGetter(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1450,17 +1450,17 @@ BinASTParser<Tok>::parseImportDeclaratio { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumImportDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumImportDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1516,17 +1516,17 @@ BinASTParser<Tok>::parseImportDeclaratio { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumImportDeclarationOrExportDeclarationOrStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumImportDeclarationOrExportDeclarationOrStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1643,17 +1643,17 @@ BinASTParser<Tok>::parseIterationStateme { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumIterationStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumIterationStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1692,17 +1692,17 @@ BinASTParser<Tok>::parseLiteral() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumLiteral(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumLiteral(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1738,17 +1738,17 @@ BinASTParser<Tok>::parseMethod() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumMethod(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumMethod(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumMethod(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1779,17 +1779,17 @@ BinASTParser<Tok>::parseMethodDefinition { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumMethodDefinition(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumMethodDefinition(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1834,17 +1834,17 @@ BinASTParser<Tok>::parseObjectProperty() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumObjectProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumObjectProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1891,17 +1891,17 @@ BinASTParser<Tok>::parseParameter() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumParameter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumParameter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1934,17 +1934,17 @@ BinASTParser<Tok>::parseProgram() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumProgram(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumProgram(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields) { @@ -1971,17 +1971,17 @@ BinASTParser<Tok>::parsePropertyName() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumPropertyName(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumPropertyName(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2008,17 +2008,17 @@ BinASTParser<Tok>::parseSetter() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumSetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumSetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumSetter(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2046,17 +2046,17 @@ BinASTParser<Tok>::parseSimpleAssignment { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumSimpleAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumSimpleAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2115,17 +2115,17 @@ BinASTParser<Tok>::parseSpreadElementOrE { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumSpreadElementOrExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumSpreadElementOrExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2261,17 +2261,17 @@ BinASTParser<Tok>::parseStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2393,17 +2393,17 @@ BinASTParser<Tok>::parseVariableDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - MOZ_TRY_DECL(result, parseSumVariableDeclarationOrExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseSumVariableDeclarationOrExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2522,17 +2522,17 @@ BinASTParser<Tok>::parseNull() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceNull(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceNull(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceNull(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2551,17 +2551,17 @@ BinASTParser<Tok>::parseArrayAssignmentT { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceArrayAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceArrayAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2580,17 +2580,17 @@ BinASTParser<Tok>::parseArrayBinding() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceArrayBinding(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayBinding(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceArrayBinding(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2608,33 +2608,33 @@ BinASTParser<Tok>::parseArrayExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceArrayExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ArrayExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Elements })); - MOZ_TRY_DECL(elements, parseListOfOptionalSpreadElementOrExpression()); + BINJS_MOZ_TRY_DECL(elements, parseListOfOptionalSpreadElementOrExpression()); auto result = elements; return result; } /* @@ -2649,17 +2649,17 @@ BinASTParser<Tok>::parseAssertedBlockSco { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssertedBlockScope(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedBlockScope(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<Ok> BinASTParser<Tok>::parseInterfaceAssertedBlockScope(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2667,17 +2667,17 @@ BinASTParser<Tok>::parseInterfaceAsserte CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval })); MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let)); MOZ_TRY(parseAndUpdateCapturedNames()); - MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); + BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); if (hasDirectEval) { parseContext_->sc()->setHasDirectEval(); parseContext_->sc()->setBindingsAccessedDynamically(); } if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) { // In non-strict mode code, direct calls to eval can // add variables to the call object. @@ -2700,17 +2700,17 @@ BinASTParser<Tok>::parseAssertedParamete { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssertedParameterScope(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedParameterScope(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<Ok> BinASTParser<Tok>::parseInterfaceAssertedParameterScope(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2718,17 +2718,17 @@ BinASTParser<Tok>::parseInterfaceAsserte CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::ParameterNames, BinField::CapturedNames, BinField::HasDirectEval })); MOZ_TRY(parseAndUpdateScopeNames(parseContext_->functionScope(), DeclarationKind:: PositionalFormalParameter)); MOZ_TRY(parseAndUpdateCapturedNames()); - MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); + BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); if (hasDirectEval) { parseContext_->sc()->setHasDirectEval(); parseContext_->sc()->setBindingsAccessedDynamically(); } if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) { // In non-strict mode code, direct calls to eval can // add variables to the call object. @@ -2752,17 +2752,17 @@ BinASTParser<Tok>::parseAssertedVarScope { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssertedVarScope(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedVarScope(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<Ok> BinASTParser<Tok>::parseInterfaceAssertedVarScope(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2771,17 +2771,17 @@ BinASTParser<Tok>::parseInterfaceAsserte MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::VarDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval })); MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let)); MOZ_TRY(parseAndUpdateScopeNames(parseContext_->varScope(), DeclarationKind::Var)); MOZ_TRY(parseAndUpdateCapturedNames()); - MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); + BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool()); if (hasDirectEval) { parseContext_->sc()->setHasDirectEval(); parseContext_->sc()->setBindingsAccessedDynamically(); } if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) { // In non-strict mode code, direct calls to eval can // add variables to the call object. @@ -2803,41 +2803,41 @@ BinASTParser<Tok>::parseAssignmentExpres { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssignmentExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::AssignmentExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Binding, BinField::Expression })); - MOZ_TRY_DECL(binding, parseAssignmentTarget()); - - - - - MOZ_TRY_DECL(expression, parseExpression()); - - - TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression)); + BINJS_MOZ_TRY_DECL(binding, parseAssignmentTarget()); + + + + + BINJS_MOZ_TRY_DECL(expression, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression)); return result; } /* interface AssignmentTargetIdentifier : Node { Identifier name; } @@ -2847,17 +2847,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAssignmentTargetIdentifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2868,17 +2868,17 @@ BinASTParser<Tok>::parseInterfaceAssignm RootedAtom name(cx_); MOZ_TRY_VAR(name, tokenizer_->readAtom()); if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); return result; } /* interface AssignmentTargetPropertyIdentifier : Node { AssignmentTargetIdentifier binding; Expression? init; @@ -2889,17 +2889,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyIdentifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyIdentifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2918,17 +2918,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2947,17 +2947,17 @@ BinASTParser<Tok>::parseAssignmentTarget { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetWithInitializer(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetWithInitializer(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields) { @@ -2975,17 +2975,17 @@ BinASTParser<Tok>::parseAwaitExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceAwaitExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceAwaitExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceAwaitExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3005,43 +3005,43 @@ BinASTParser<Tok>::parseBinaryExpression { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBinaryExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBinaryExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBinaryExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::BinaryExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Left, BinField::Right })); - MOZ_TRY_DECL(operator_, parseBinaryOperator()); - - - - - MOZ_TRY_DECL(left, parseExpression()); - - - - - MOZ_TRY_DECL(right, parseExpression()); + BINJS_MOZ_TRY_DECL(operator_, parseBinaryOperator()); + + + + + BINJS_MOZ_TRY_DECL(left, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(right, parseExpression()); ParseNodeKind pnk; switch (operator_) { case BinaryOperator::Comma: pnk = ParseNodeKind::Comma; break; case BinaryOperator::LogicalOr: @@ -3121,17 +3121,17 @@ BinASTParser<Tok>::parseInterfaceBinaryE ParseNode* result; if (left->isKind(pnk) && pnk != ParseNodeKind::Pow /* ParseNodeKind::Pow is not left-associative */) { // Regroup left-associative operations into lists. left->appendWithoutOrderAssumption(right); result = left; } else { - TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start))); + BINJS_TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start))); list->appendWithoutOrderAssumption(left); list->appendWithoutOrderAssumption(right); result = list; } return result; } @@ -3146,17 +3146,17 @@ BinASTParser<Tok>::parseBindingIdentifie { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBindingIdentifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingIdentifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBindingIdentifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3167,17 +3167,17 @@ BinASTParser<Tok>::parseInterfaceBinding RootedAtom name(cx_); MOZ_TRY_VAR(name, tokenizer_->readAtom()); if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); return result; } /* interface BindingPropertyIdentifier : Node { BindingIdentifier binding; Expression? init; @@ -3188,17 +3188,17 @@ BinASTParser<Tok>::parseBindingPropertyI { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBindingPropertyIdentifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingPropertyIdentifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBindingPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3217,17 +3217,17 @@ BinASTParser<Tok>::parseBindingPropertyP { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBindingPropertyProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingPropertyProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBindingPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3246,17 +3246,17 @@ BinASTParser<Tok>::parseBindingWithIniti { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBindingWithInitializer(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingWithInitializer(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3275,44 +3275,44 @@ BinASTParser<Tok>::parseBlock() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBlock(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBlock(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBlock(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::Block); CheckRecursionLimit(cx_); - MOZ_TRY(checkFields(kind, fields, { BinField::Scope, BinField::Statements })); + MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Scope, BinField::Statements })); ParseContext::Statement stmt(parseContext_, StatementKind::Block); ParseContext::Scope currentScope(cx_, parseContext_, usedNames_); - TRY(currentScope.init(parseContext_)); + BINJS_TRY(currentScope.init(parseContext_)); MOZ_TRY(parseOptionalAssertedBlockScope()); - MOZ_TRY_DECL(statements, parseListOfStatement()); - - - TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); - TRY_DECL(result, factory_.newLexicalScope(*bindings, statements)); + BINJS_MOZ_TRY_DECL(statements, parseListOfStatement()); + + + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); + BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, statements)); return result; } /* interface BreakStatement : Node { Label? label; } @@ -3322,17 +3322,17 @@ BinASTParser<Tok>::parseBreakStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceBreakStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceBreakStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceBreakStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3353,17 +3353,17 @@ BinASTParser<Tok>::parseInterfaceBreakSt switch (validity.unwrapErr()) { case ParseContext::BreakStatementError::ToughBreak: return raiseError(kind, "Not in a loop"); case ParseContext::BreakStatementError::LabelNotFound: return raiseError(kind, "Label not found"); } } } - TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); return result; } /* interface CallExpression : Node { (Expression or Super) callee; Arguments arguments; @@ -3374,38 +3374,38 @@ BinASTParser<Tok>::parseCallExpression() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceCallExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceCallExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceCallExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::CallExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Callee, BinField::Arguments })); - MOZ_TRY_DECL(callee, parseExpressionOrSuper()); - - - - - MOZ_TRY_DECL(arguments, parseArguments()); + BINJS_MOZ_TRY_DECL(callee, parseExpressionOrSuper()); + + + + + BINJS_MOZ_TRY_DECL(arguments, parseArguments()); auto op = JSOP_CALL; // Check for direct calls to `eval`. if (factory_.isEvalName(callee, cx_)) { if (!parseContext_->varScope().lookupDeclaredNameForAdd(callee->name()) && !parseContext_->innermostScope()->lookupDeclaredNameForAdd(callee->name())) { // This is a direct call to `eval`. @@ -3420,71 +3420,65 @@ BinASTParser<Tok>::parseInterfaceCallExp result->prepend(callee); result->setOp(op); return result; } /* interface CatchClause : Node { - AssertedParameterScope? bindingScope; Binding binding; Block body; } */ template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseCatchClause() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceCatchClause(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceCatchClause(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceCatchClause(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::CatchClause); CheckRecursionLimit(cx_); - MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::BindingScope, BinField::Binding, BinField::Body })); + MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Binding, BinField::Body })); ParseContext::Statement stmt(parseContext_, StatementKind::Catch); ParseContext::Scope currentScope(cx_, parseContext_, usedNames_); - TRY(currentScope.init(parseContext_)); - - - MOZ_TRY(parseOptionalAssertedParameterScope()); - - - - - MOZ_TRY_DECL(binding, parseBinding()); - - - - - MOZ_TRY_DECL(body, parseBlock()); + BINJS_TRY(currentScope.init(parseContext_)); + + + BINJS_MOZ_TRY_DECL(binding, parseBinding()); + + + + + BINJS_MOZ_TRY_DECL(body, parseBlock()); // Export implicit variables to the scope. // FIXME: Handle cases other than Name. MOZ_ASSERT(binding->isKind(ParseNodeKind::Name)); auto ptr = currentScope.lookupDeclaredNameForAdd(binding->name()); - TRY(currentScope.addDeclaredName(parseContext_, ptr, binding->name(), DeclarationKind::Let, start)); - - TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); - TRY_DECL(result, factory_.newLexicalScope(*bindings, body)); - TRY(factory_.setupCatchScope(result, binding, body)); + BINJS_TRY(currentScope.addDeclaredName(parseContext_, ptr, binding->name(), DeclarationKind::Let, start)); + + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); + BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, body)); + BINJS_TRY(factory_.setupCatchScope(result, binding, body)); return result; } /* interface ClassDeclaration : Node { BindingIdentifier name; Expression? super; @@ -3496,17 +3490,17 @@ BinASTParser<Tok>::parseClassDeclaration { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceClassDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceClassDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceClassDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3525,17 +3519,17 @@ BinASTParser<Tok>::parseClassElement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceClassElement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceClassElement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceClassElement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3555,17 +3549,17 @@ BinASTParser<Tok>::parseClassExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceClassExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceClassExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceClassExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3585,43 +3579,43 @@ BinASTParser<Tok>::parseCompoundAssignme { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceCompoundAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::CompoundAssignmentExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Binding, BinField::Expression })); - MOZ_TRY_DECL(operator_, parseCompoundAssignmentOperator()); - - - - - MOZ_TRY_DECL(binding, parseSimpleAssignmentTarget()); - - - - - MOZ_TRY_DECL(expression, parseExpression()); + BINJS_MOZ_TRY_DECL(operator_, parseCompoundAssignmentOperator()); + + + + + BINJS_MOZ_TRY_DECL(binding, parseSimpleAssignmentTarget()); + + + + + BINJS_MOZ_TRY_DECL(expression, parseExpression()); ParseNodeKind pnk; switch (operator_){ case CompoundAssignmentOperator::PlusAssign: pnk = ParseNodeKind::AddAssign; break; case CompoundAssignmentOperator::MinusAssign: @@ -3653,17 +3647,17 @@ BinASTParser<Tok>::parseInterfaceCompoun break; case CompoundAssignmentOperator::BitXorAssign: pnk = ParseNodeKind::BitXorAssign; break; case CompoundAssignmentOperator::BitAndAssign: pnk = ParseNodeKind::BitAndAssign; break; } - TRY_DECL(result, factory_.newAssignment(pnk, binding, expression)); + BINJS_TRY_DECL(result, factory_.newAssignment(pnk, binding, expression)); return result; } /* interface ComputedMemberAssignmentTarget : Node { (Expression or Super) object; Expression expression; @@ -3674,41 +3668,41 @@ BinASTParser<Tok>::parseComputedMemberAs { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceComputedMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ComputedMemberAssignmentTarget); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Expression })); - MOZ_TRY_DECL(object, parseExpressionOrSuper()); - - - - - MOZ_TRY_DECL(expression, parseExpression()); - - - TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); + BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper()); + + + + + BINJS_MOZ_TRY_DECL(expression, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); return result; } /* interface ComputedMemberExpression : Node { (Expression or Super) object; Expression expression; @@ -3719,41 +3713,41 @@ BinASTParser<Tok>::parseComputedMemberEx { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceComputedMemberExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedMemberExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceComputedMemberExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ComputedMemberExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Expression })); - MOZ_TRY_DECL(object, parseExpressionOrSuper()); - - - - - MOZ_TRY_DECL(expression, parseExpression()); - - - TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); + BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper()); + + + + + BINJS_MOZ_TRY_DECL(expression, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); return result; } /* interface ComputedPropertyName : Node { Expression expression; } @@ -3763,17 +3757,17 @@ BinASTParser<Tok>::parseComputedProperty { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceComputedPropertyName(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedPropertyName(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceComputedPropertyName(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3793,46 +3787,46 @@ BinASTParser<Tok>::parseConditionalExpre { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceConditionalExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceConditionalExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ConditionalExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate })); - MOZ_TRY_DECL(test, parseExpression()); - - - - - MOZ_TRY_DECL(consequent, parseExpression()); - - - - - MOZ_TRY_DECL(alternate, parseExpression()); - - - TRY_DECL(result, factory_.newConditional(test, consequent, alternate)); + BINJS_MOZ_TRY_DECL(test, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(consequent, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(alternate, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newConditional(test, consequent, alternate)); return result; } /* interface ContinueStatement : Node { Label? label; } @@ -3842,17 +3836,17 @@ BinASTParser<Tok>::parseContinueStatemen { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceContinueStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceContinueStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceContinueStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3873,17 +3867,17 @@ BinASTParser<Tok>::parseInterfaceContinu case ParseContext::ContinueStatementError::NotInALoop: return raiseError(kind, "Not in a loop"); case ParseContext::ContinueStatementError::LabelNotFound: return raiseError(kind, "Label not found"); } } } - TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); return result; } /* interface DataProperty : Node { PropertyName name; Expression expression; @@ -3894,44 +3888,44 @@ BinASTParser<Tok>::parseDataProperty() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceDataProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceDataProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceDataProperty(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::DataProperty); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name, BinField::Expression })); - MOZ_TRY_DECL(name, parsePropertyName()); - - - - - MOZ_TRY_DECL(expression, parseExpression()); + BINJS_MOZ_TRY_DECL(name, parsePropertyName()); + + + + + BINJS_MOZ_TRY_DECL(expression, parseExpression()); if (!factory_.isUsableAsObjectPropertyName(name)) return raiseError("DataProperty key kind"); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None)); return result; } /* interface DebuggerStatement : Node { } */ @@ -3940,17 +3934,17 @@ BinASTParser<Tok>::parseDebuggerStatemen { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceDebuggerStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceDebuggerStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceDebuggerStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3968,17 +3962,17 @@ BinASTParser<Tok>::parseDirective() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceDirective(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceDirective(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceDirective(const size_t start, const BinKind kind, const BinFields& fields) { @@ -3988,17 +3982,17 @@ BinASTParser<Tok>::parseInterfaceDirecti MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::RawValue })); RootedAtom rawValue(cx_); MOZ_TRY_VAR(rawValue, tokenizer_->readAtom()); TokenPos pos = tokenizer_->pos(start); - TRY_DECL(result, factory_.newStringLiteral(rawValue, pos)); + BINJS_TRY_DECL(result, factory_.newStringLiteral(rawValue, pos)); return result; } /* interface DoWhileStatement : Node { Expression test; Statement body; @@ -4009,41 +4003,41 @@ BinASTParser<Tok>::parseDoWhileStatement { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceDoWhileStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceDoWhileStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceDoWhileStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::DoWhileStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Body })); ParseContext::Statement stmt(parseContext_, StatementKind::DoLoop); - MOZ_TRY_DECL(test, parseExpression()); - - - - - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start))); + BINJS_MOZ_TRY_DECL(test, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start))); return result; } /* interface EagerArrowExpression : Node { bool isAsync; AssertedParameterScope? parameterScope; @@ -4057,17 +4051,17 @@ BinASTParser<Tok>::parseEagerArrowExpres { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerArrowExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerArrowExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerArrowExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4091,26 +4085,83 @@ BinASTParser<Tok>::parseEagerFunctionDec { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { - return raiseError("FIXME: Not implemented yet (EagerFunctionDeclaration)"); + MOZ_ASSERT(kind == BinKind::EagerFunctionDeclaration); + CheckRecursionLimit(cx_); + + MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body })); + const auto syntax = FunctionSyntaxKind::Statement; + + + BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool()); + + + + + BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool()); + + + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + isGenerator ? GeneratorKind::Generator + : GeneratorKind::NotGenerator, + isAsync ? FunctionAsyncKind::AsyncFunction + : FunctionAsyncKind::SyncFunction, + syntax)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + + MOZ_TRY(parseOptionalAssertedParameterScope()); + + + + + MOZ_TRY(parseOptionalAssertedVarScope()); + + + + + BINJS_MOZ_TRY_DECL(name, parseBindingIdentifier()); + + + + + BINJS_MOZ_TRY_DECL(params, parseFormalParameters()); + + + + + BINJS_MOZ_TRY_DECL(body, parseFunctionBody()); + + + BINJS_TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_)); + BINJS_TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body)); + BINJS_MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox)); + return result; } /* interface EagerFunctionExpression : Node { bool isAsync; bool isGenerator; AssertedParameterScope? parameterScope; @@ -4125,81 +4176,82 @@ BinASTParser<Tok>::parseEagerFunctionExp { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::EagerFunctionExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body })); - - - - MOZ_TRY_DECL(isAsync, tokenizer_->readBool()); - - - - - MOZ_TRY_DECL(isGenerator, tokenizer_->readBool()); - - - MOZ_TRY_DECL(funbox, buildFunctionBox( + const auto syntax = FunctionSyntaxKind::Expression; + + + BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool()); + + + + + BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool()); + + + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( isGenerator ? GeneratorKind::Generator : GeneratorKind::NotGenerator, isAsync ? FunctionAsyncKind::AsyncFunction - : FunctionAsyncKind::SyncFunction)); + : FunctionAsyncKind::SyncFunction, + syntax)); // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); - TRY(funpc.init()); + BINJS_TRY(funpc.init()); parseContext_->functionScope().useAsVarScope(parseContext_); MOZ_ASSERT(parseContext_->isFunctionBox()); ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); - TRY(lexicalScope.init(parseContext_)); + BINJS_TRY(lexicalScope.init(parseContext_)); MOZ_TRY(parseOptionalAssertedParameterScope()); MOZ_TRY(parseOptionalAssertedVarScope()); - MOZ_TRY_DECL(name, parseOptionalBindingIdentifier()); - - - - - MOZ_TRY_DECL(params, parseFormalParameters()); - - - - - MOZ_TRY_DECL(body, parseFunctionBody()); - - - TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_)); - TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body)); - MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox)); + BINJS_MOZ_TRY_DECL(name, parseOptionalBindingIdentifier()); + + + + + BINJS_MOZ_TRY_DECL(params, parseFormalParameters()); + + + + + BINJS_MOZ_TRY_DECL(body, parseFunctionBody()); + + + BINJS_TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_)); + BINJS_TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body)); + BINJS_MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox)); return result; } /* interface EagerGetter : Node { AssertedVarScope? bodyScope; PropertyName name; @@ -4211,26 +4263,61 @@ BinASTParser<Tok>::parseEagerGetter() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerGetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerGetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerGetter(const size_t start, const BinKind kind, const BinFields& fields) { - return raiseError("FIXME: Not implemented yet (EagerGetter)"); + MOZ_ASSERT(kind == BinKind::EagerGetter); + CheckRecursionLimit(cx_); + + MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::BodyScope, BinField::Name, BinField::Body })); + + + + MOZ_TRY(parseOptionalAssertedVarScope()); + + + + + BINJS_MOZ_TRY_DECL(name, parsePropertyName()); + + + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + GeneratorKind::NotGenerator, + FunctionAsyncKind::SyncFunction, + FunctionSyntaxKind::Getter)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + + BINJS_MOZ_TRY_DECL(body, parseFunctionBody()); + + + ParseNode* params = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start)); + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Getter)); + return result; } /* interface EagerMethod : Node { bool isAsync; bool isGenerator; AssertedParameterScope? parameterScope; @@ -4245,80 +4332,81 @@ BinASTParser<Tok>::parseEagerMethod() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerMethod(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerMethod(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerMethod(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::EagerMethod); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body })); - - - - MOZ_TRY_DECL(isAsync, tokenizer_->readBool()); - - - - - MOZ_TRY_DECL(isGenerator, tokenizer_->readBool()); - - - MOZ_TRY_DECL(funbox, buildFunctionBox( + const auto syntax = FunctionSyntaxKind::Method; + + + BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool()); + + + + + BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool()); + + + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( isGenerator ? GeneratorKind::Generator : GeneratorKind::NotGenerator, isAsync ? FunctionAsyncKind::AsyncFunction - : FunctionAsyncKind::SyncFunction)); + : FunctionAsyncKind::SyncFunction, + syntax)); // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); - TRY(funpc.init()); + BINJS_TRY(funpc.init()); parseContext_->functionScope().useAsVarScope(parseContext_); MOZ_ASSERT(parseContext_->isFunctionBox()); ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); - TRY(lexicalScope.init(parseContext_)); + BINJS_TRY(lexicalScope.init(parseContext_)); MOZ_TRY(parseOptionalAssertedParameterScope()); MOZ_TRY(parseOptionalAssertedVarScope()); - MOZ_TRY_DECL(name, parsePropertyName()); - - - - - MOZ_TRY_DECL(params, parseFormalParameters()); - - - - - MOZ_TRY_DECL(body, parseFunctionBody()); - - - MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None)); + BINJS_MOZ_TRY_DECL(name, parsePropertyName()); + + + + + BINJS_MOZ_TRY_DECL(params, parseFormalParameters()); + + + + + BINJS_MOZ_TRY_DECL(body, parseFunctionBody()); + + + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None)); return result; } /* interface EagerSetter : Node { AssertedParameterScope? parameterScope; AssertedVarScope? bodyScope; @@ -4332,26 +4420,72 @@ BinASTParser<Tok>::parseEagerSetter() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEagerSetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerSetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEagerSetter(const size_t start, const BinKind kind, const BinFields& fields) { - return raiseError("FIXME: Not implemented yet (EagerSetter)"); + MOZ_ASSERT(kind == BinKind::EagerSetter); + CheckRecursionLimit(cx_); + + MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Param, BinField::Body })); + + + + MOZ_TRY(parseOptionalAssertedParameterScope()); + + + + + MOZ_TRY(parseOptionalAssertedVarScope()); + + + + + BINJS_MOZ_TRY_DECL(name, parsePropertyName()); + + + + + BINJS_MOZ_TRY_DECL(param, parseParameter()); + + + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + GeneratorKind::NotGenerator, + FunctionAsyncKind::SyncFunction, + FunctionSyntaxKind::Setter)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + + BINJS_MOZ_TRY_DECL(body, parseFunctionBody()); + + + ParseNode* params = new_<ListNode>(ParseNodeKind::ParamsBody, param->pn_pos); + factory_.addList(params, param); + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter)); + return result; } /* interface EmptyStatement : Node { } */ template<typename Tok> JS::Result<ParseNode*> @@ -4359,31 +4493,31 @@ BinASTParser<Tok>::parseEmptyStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceEmptyStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceEmptyStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceEmptyStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::EmptyStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields0(kind, fields)); - TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start))); return result; } /* interface Export : Node { (FunctionDeclaration or ClassDeclaration or VariableDeclaration) declaration; } @@ -4393,17 +4527,17 @@ BinASTParser<Tok>::parseExport() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExport(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExport(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExport(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4421,17 +4555,17 @@ BinASTParser<Tok>::parseExportAllFrom() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportAllFrom(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportAllFrom(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportAllFrom(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4449,17 +4583,17 @@ BinASTParser<Tok>::parseExportDefault() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportDefault(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportDefault(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportDefault(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4478,17 +4612,17 @@ BinASTParser<Tok>::parseExportFrom() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportFrom(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportFrom(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportFrom(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4507,17 +4641,17 @@ BinASTParser<Tok>::parseExportFromSpecif { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportFromSpecifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportFromSpecifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportFromSpecifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4536,17 +4670,17 @@ BinASTParser<Tok>::parseExportLocalSpeci { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportLocalSpecifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportLocalSpecifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportLocalSpecifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4564,17 +4698,17 @@ BinASTParser<Tok>::parseExportLocals() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExportLocals(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExportLocals(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExportLocals(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4592,36 +4726,36 @@ BinASTParser<Tok>::parseExpressionStatem { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceExpressionStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceExpressionStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ExpressionStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Expression })); - MOZ_TRY_DECL(expression, parseExpression()); - - - TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset())); + BINJS_MOZ_TRY_DECL(expression, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset())); return result; } /* interface ForInOfBinding : Node { VariableDeclarationKind kind; Binding binding; @@ -4632,48 +4766,48 @@ BinASTParser<Tok>::parseForInOfBinding() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceForInOfBinding(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceForInOfBinding(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceForInOfBinding(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ForInOfBinding); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Kind, BinField::Binding })); AutoVariableDeclarationKind kindGuard(this); - MOZ_TRY_DECL(kind_, parseVariableDeclarationKind()); - - - - - MOZ_TRY_DECL(binding, parseBinding()); + BINJS_MOZ_TRY_DECL(kind_, parseVariableDeclarationKind()); + + + + + BINJS_MOZ_TRY_DECL(binding, parseBinding()); // Restored by `kindGuard`. variableDeclarationKind_ = kind_; MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName())); auto pnk = kind_ == VariableDeclarationKind::Let ? ParseNodeKind::Let : ParseNodeKind::Var; - TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start))); factory_.addList(result, binding); return result; } /* interface ForInStatement : Node { (ForInOfBinding or AssignmentTarget) left; @@ -4686,17 +4820,17 @@ BinASTParser<Tok>::parseForInStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceForInStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceForInStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceForInStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4705,38 +4839,38 @@ BinASTParser<Tok>::parseInterfaceForInSt MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Left, BinField::Right, BinField::Body })); ParseContext::Statement stmt(parseContext_, StatementKind::ForInLoop); // Implicit scope around the `for`, used to store `for (let x in ...)` // or `for (const x in ...)`-style declarations. Detail on the // declaration is stored as part of `scope`. ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); - - - MOZ_TRY_DECL(left, parseForInOfBindingOrAssignmentTarget()); - - - - - MOZ_TRY_DECL(right, parseExpression()); - - - - - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start))); - TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0)); + BINJS_TRY(scope.init(parseContext_)); + + + BINJS_MOZ_TRY_DECL(left, parseForInOfBindingOrAssignmentTarget()); + + + + + BINJS_MOZ_TRY_DECL(right, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0)); if (!scope.isEmpty()) { - TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); - TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); + BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); } return result; } /* interface ForOfStatement : Node { (ForInOfBinding or AssignmentTarget) left; @@ -4749,17 +4883,17 @@ BinASTParser<Tok>::parseForOfStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceForOfStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceForOfStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceForOfStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4780,17 +4914,17 @@ BinASTParser<Tok>::parseForStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceForStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceForStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceForStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4799,43 +4933,43 @@ BinASTParser<Tok>::parseInterfaceForStat MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Init, BinField::Test, BinField::Update, BinField::Body })); ParseContext::Statement stmt(parseContext_, StatementKind::ForLoop); // Implicit scope around the `for`, used to store `for (let x; ...; ...)` // or `for (const x; ...; ...)`-style declarations. Detail on the // declaration is stored as part of `BINJS_Scope`. ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); - - - MOZ_TRY_DECL(init, parseOptionalVariableDeclarationOrExpression()); - - - - - MOZ_TRY_DECL(test, parseOptionalExpression()); - - - - - MOZ_TRY_DECL(update, parseOptionalExpression()); - - - - - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start))); - TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0)); + BINJS_TRY(scope.init(parseContext_)); + + + BINJS_MOZ_TRY_DECL(init, parseOptionalVariableDeclarationOrExpression()); + + + + + BINJS_MOZ_TRY_DECL(test, parseOptionalExpression()); + + + + + BINJS_MOZ_TRY_DECL(update, parseOptionalExpression()); + + + + + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0)); if (!scope.isEmpty()) { - TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); - TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); + BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); } return result; } /* interface FormalParameters : Node { FrozenArray<Parameter> items; @@ -4847,43 +4981,43 @@ BinASTParser<Tok>::parseFormalParameters { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceFormalParameters(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceFormalParameters(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceFormalParameters(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::FormalParameters); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Items, BinField::Rest })); - MOZ_TRY_DECL(items, parseListOfParameter()); - - - - - MOZ_TRY_DECL(rest, parseOptionalBinding()); + BINJS_MOZ_TRY_DECL(items, parseListOfParameter()); + + + + + BINJS_MOZ_TRY_DECL(rest, parseOptionalBinding()); auto result = items; if (rest) { - TRY_DECL(spread, factory_.newSpread(start, rest)); + BINJS_TRY_DECL(spread, factory_.newSpread(start, rest)); factory_.addList(result, spread); } return result; } /* interface FunctionBody : Node { @@ -4896,41 +5030,41 @@ BinASTParser<Tok>::parseFunctionBody() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceFunctionBody(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceFunctionBody(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceFunctionBody(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::FunctionBody); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Directives, BinField::Statements })); - MOZ_TRY_DECL(directives, parseListOfDirective()); - - - - - MOZ_TRY_DECL(statements, parseListOfStatement()); - - - MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); + BINJS_MOZ_TRY_DECL(directives, parseListOfDirective()); + + + + + BINJS_MOZ_TRY_DECL(statements, parseListOfStatement()); + + + BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); return result; } /* interface IdentifierExpression : Node { Identifier name; } @@ -4940,17 +5074,17 @@ BinASTParser<Tok>::parseIdentifierExpres { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceIdentifierExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceIdentifierExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceIdentifierExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -4961,17 +5095,17 @@ BinASTParser<Tok>::parseInterfaceIdentif RootedAtom name(cx_); MOZ_TRY_VAR(name, tokenizer_->readAtom()); if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); return result; } /* interface IfStatement : Node { Expression test; Statement consequent; @@ -4983,46 +5117,46 @@ BinASTParser<Tok>::parseIfStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceIfStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceIfStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceIfStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::IfStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate })); - MOZ_TRY_DECL(test, parseExpression()); - - - - - MOZ_TRY_DECL(consequent, parseStatement()); - - - - - MOZ_TRY_DECL(alternate, parseOptionalStatement()); - - - TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate)); + BINJS_MOZ_TRY_DECL(test, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(consequent, parseStatement()); + + + + + BINJS_MOZ_TRY_DECL(alternate, parseOptionalStatement()); + + + BINJS_TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate)); return result; } /* interface Import : Node { string moduleSpecifier; BindingIdentifier? defaultBinding; @@ -5034,17 +5168,17 @@ BinASTParser<Tok>::parseImport() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceImport(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceImport(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceImport(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5064,17 +5198,17 @@ BinASTParser<Tok>::parseImportNamespace( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceImportNamespace(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceImportNamespace(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceImportNamespace(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5093,17 +5227,17 @@ BinASTParser<Tok>::parseImportSpecifier( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceImportSpecifier(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceImportSpecifier(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceImportSpecifier(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5122,17 +5256,17 @@ BinASTParser<Tok>::parseLabelledStatemen { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLabelledStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLabelledStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLabelledStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5145,20 +5279,20 @@ BinASTParser<Tok>::parseInterfaceLabelle RootedAtom label(cx_); MOZ_TRY_VAR(label, tokenizer_->readAtom()); if (!IsIdentifier(label)) return raiseError("Invalid identifier"); ParseContext::LabelStatement stmt(parseContext_, label); - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start)); + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start)); return result; } /* interface LiteralBooleanExpression : Node { bool value; } @@ -5168,36 +5302,36 @@ BinASTParser<Tok>::parseLiteralBooleanEx { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value })); - MOZ_TRY_DECL(value, tokenizer_->readBool()); - - - TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start))); + BINJS_MOZ_TRY_DECL(value, tokenizer_->readBool()); + + + BINJS_TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start))); return result; } /* interface LiteralInfinityExpression : Node { } */ @@ -5206,17 +5340,17 @@ BinASTParser<Tok>::parseLiteralInfinityE { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralInfinityExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5233,31 +5367,31 @@ BinASTParser<Tok>::parseLiteralNullExpre { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralNullExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralNullExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::LiteralNullExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields0(kind, fields)); - TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start))); return result; } /* interface LiteralNumericExpression : Node { number value; } @@ -5267,36 +5401,36 @@ BinASTParser<Tok>::parseLiteralNumericEx { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralNumericExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::LiteralNumericExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value })); - MOZ_TRY_DECL(value, tokenizer_->readDouble()); - - - TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start))); + BINJS_MOZ_TRY_DECL(value, tokenizer_->readDouble()); + + + BINJS_TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start))); return result; } /* interface LiteralPropertyName : Node { string value; } @@ -5306,17 +5440,17 @@ BinASTParser<Tok>::parseLiteralPropertyN { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralPropertyName(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralPropertyName(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralPropertyName(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5328,19 +5462,19 @@ BinASTParser<Tok>::parseInterfaceLiteral RootedAtom value(cx_); MOZ_TRY_VAR(value, tokenizer_->readAtom()); ParseNode* result; uint32_t index; if (value->isIndex(&index)) - TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset()))); + BINJS_TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset()))); else - TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start))); + BINJS_TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start))); return result; } /* interface LiteralRegExpExpression : Node { string pattern; string flags; @@ -5351,17 +5485,17 @@ BinASTParser<Tok>::parseLiteralRegExpExp { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralRegExpExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5390,23 +5524,23 @@ BinASTParser<Tok>::parseInterfaceLiteral else if (c == 'u' && !(reflags & UnicodeFlag)) reflags = RegExpFlag(reflags | UnicodeFlag); else return raiseError("Invalid regexp flags"); } Rooted<RegExpObject*> reobj(cx_); - TRY_VAR(reobj, RegExpObject::create(cx_, + BINJS_TRY_VAR(reobj, RegExpObject::create(cx_, pattern, reflags, alloc_, TenuredObject)); - TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this)); + BINJS_TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this)); return result; } /* interface LiteralStringExpression : Node { string value; } @@ -5416,17 +5550,17 @@ BinASTParser<Tok>::parseLiteralStringExp { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceLiteralStringExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralStringExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceLiteralStringExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5435,17 +5569,17 @@ BinASTParser<Tok>::parseInterfaceLiteral MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value })); RootedAtom value(cx_); MOZ_TRY_VAR(value, tokenizer_->readAtom()); - TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start))); return result; } /* interface Module : Node { AssertedVarScope? scope; FrozenArray<Directive> directives; @@ -5457,17 +5591,17 @@ BinASTParser<Tok>::parseModule() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceModule(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceModule(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceModule(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5486,38 +5620,38 @@ BinASTParser<Tok>::parseNewExpression() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceNewExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceNewExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::NewExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Callee, BinField::Arguments })); - MOZ_TRY_DECL(callee, parseExpression()); - - - - - MOZ_TRY_DECL(arguments, parseArguments()); + BINJS_MOZ_TRY_DECL(callee, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(arguments, parseArguments()); auto result = arguments; result->setKind(ParseNodeKind::New); result->prepend(callee); return result; } @@ -5531,17 +5665,17 @@ BinASTParser<Tok>::parseNewTargetExpress { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceNewTargetExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceNewTargetExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceNewTargetExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5559,17 +5693,17 @@ BinASTParser<Tok>::parseObjectAssignment { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceObjectAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceObjectAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5587,17 +5721,17 @@ BinASTParser<Tok>::parseObjectBinding() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceObjectBinding(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectBinding(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceObjectBinding(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5615,33 +5749,33 @@ BinASTParser<Tok>::parseObjectExpression { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceObjectExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ObjectExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Properties })); - MOZ_TRY_DECL(properties, parseListOfObjectProperty()); + BINJS_MOZ_TRY_DECL(properties, parseListOfObjectProperty()); auto result = properties; return result; } /* @@ -5654,17 +5788,17 @@ BinASTParser<Tok>::parseReturnStatement( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceReturnStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceReturnStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceReturnStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5675,20 +5809,20 @@ BinASTParser<Tok>::parseInterfaceReturnS if (!parseContext_->isFunctionBox()) { // Return statements are permitted only inside functions. return raiseInvalidKind("Toplevel Statement", kind); } parseContext_->functionBox()->usesReturn = true; - MOZ_TRY_DECL(expression, parseOptionalExpression()); - - - TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start))); + BINJS_MOZ_TRY_DECL(expression, parseOptionalExpression()); + + + BINJS_TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start))); return result; } /* interface Script : Node { AssertedVarScope? scope; FrozenArray<Directive> directives; @@ -5700,17 +5834,17 @@ BinASTParser<Tok>::parseScript() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceScript(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceScript(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceScript(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5721,25 +5855,25 @@ BinASTParser<Tok>::parseInterfaceScript( MOZ_TRY(parseOptionalAssertedVarScope()); - MOZ_TRY_DECL(directives, parseListOfDirective()); - - - - - MOZ_TRY_DECL(statements, parseListOfStatement()); - - - MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); + BINJS_MOZ_TRY_DECL(directives, parseListOfDirective()); + + + + + BINJS_MOZ_TRY_DECL(statements, parseListOfStatement()); + + + BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); return result; } /* interface ShorthandProperty : Node { IdentifierExpression name; } @@ -5749,39 +5883,39 @@ BinASTParser<Tok>::parseShorthandPropert { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceShorthandProperty(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceShorthandProperty(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceShorthandProperty(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ShorthandProperty); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name })); - MOZ_TRY_DECL(name, parseIdentifierExpression()); + BINJS_MOZ_TRY_DECL(name, parseIdentifierExpression()); if (!factory_.isUsableAsObjectPropertyName(name)) - TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start))); - - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None)); + BINJS_TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start))); + + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None)); return result; } /* interface SkippableArrowExpression : Node { EagerArrowExpression skipped; } @@ -5791,17 +5925,17 @@ BinASTParser<Tok>::parseSkippableArrowEx { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableArrowExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableArrowExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableArrowExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5819,17 +5953,17 @@ BinASTParser<Tok>::parseSkippableFunctio { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5847,17 +5981,17 @@ BinASTParser<Tok>::parseSkippableFunctio { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5875,17 +6009,17 @@ BinASTParser<Tok>::parseSkippableGetter( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableGetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableGetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableGetter(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5903,17 +6037,17 @@ BinASTParser<Tok>::parseSkippableMethod( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableMethod(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableMethod(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableMethod(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5931,17 +6065,17 @@ BinASTParser<Tok>::parseSkippableSetter( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSkippableSetter(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableSetter(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSkippableSetter(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5959,17 +6093,17 @@ BinASTParser<Tok>::parseSpreadElement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSpreadElement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSpreadElement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSpreadElement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -5988,41 +6122,41 @@ BinASTParser<Tok>::parseStaticMemberAssi { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::StaticMemberAssignmentTarget); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Property })); - MOZ_TRY_DECL(object, parseExpressionOrSuper()); + BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper()); RootedAtom property(cx_); MOZ_TRY_VAR(property, tokenizer_->readAtom()); - TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); + BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); return result; } /* interface StaticMemberExpression : Node { (Expression or Super) object; IdentifierName property; @@ -6033,41 +6167,41 @@ BinASTParser<Tok>::parseStaticMemberExpr { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceStaticMemberExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceStaticMemberExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceStaticMemberExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::StaticMemberExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Property })); - MOZ_TRY_DECL(object, parseExpressionOrSuper()); + BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper()); RootedAtom property(cx_); MOZ_TRY_VAR(property, tokenizer_->readAtom()); - TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); + BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); return result; } /* interface Super : Node { } */ @@ -6076,17 +6210,17 @@ BinASTParser<Tok>::parseSuper() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSuper(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSuper(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSuper(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6105,41 +6239,41 @@ BinASTParser<Tok>::parseSwitchCase() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSwitchCase(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchCase(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSwitchCase(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::SwitchCase); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent })); - MOZ_TRY_DECL(test, parseExpression()); - - - - - MOZ_TRY_DECL(consequent, parseListOfStatement()); - - - TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent)); + BINJS_MOZ_TRY_DECL(test, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(consequent, parseListOfStatement()); + + + BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent)); return result; } /* interface SwitchDefault : Node { FrozenArray<Statement> consequent; } @@ -6149,36 +6283,36 @@ BinASTParser<Tok>::parseSwitchDefault() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSwitchDefault(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchDefault(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSwitchDefault(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::SwitchDefault); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Consequent })); - MOZ_TRY_DECL(consequent, parseListOfStatement()); - - - TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent)); + BINJS_MOZ_TRY_DECL(consequent, parseListOfStatement()); + + + BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent)); return result; } /* interface SwitchStatement : Node { Expression discriminant; FrozenArray<SwitchCase> cases; @@ -6189,42 +6323,42 @@ BinASTParser<Tok>::parseSwitchStatement( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSwitchStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSwitchStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::SwitchStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Discriminant, BinField::Cases })); - MOZ_TRY_DECL(discriminant, parseExpression()); - - - - - MOZ_TRY_DECL(cases, parseListOfSwitchCase()); - - - TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); - TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); + BINJS_MOZ_TRY_DECL(discriminant, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(cases, parseListOfSwitchCase()); + + + BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); + BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); return result; } /* interface SwitchStatementWithDefault : Node { Expression discriminant; FrozenArray<SwitchCase> preDefaultCases; @@ -6237,61 +6371,61 @@ BinASTParser<Tok>::parseSwitchStatementW { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceSwitchStatementWithDefault(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::SwitchStatementWithDefault); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Discriminant, BinField::PreDefaultCases, BinField::DefaultCase, BinField::PostDefaultCases })); - MOZ_TRY_DECL(discriminant, parseExpression()); - - - - - MOZ_TRY_DECL(preDefaultCases, parseListOfSwitchCase()); - - - - - MOZ_TRY_DECL(defaultCase, parseSwitchDefault()); - - - - - MOZ_TRY_DECL(postDefaultCases, parseListOfSwitchCase()); + BINJS_MOZ_TRY_DECL(discriminant, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(preDefaultCases, parseListOfSwitchCase()); + + + + + BINJS_MOZ_TRY_DECL(defaultCase, parseSwitchDefault()); + + + + + BINJS_MOZ_TRY_DECL(postDefaultCases, parseListOfSwitchCase()); // Concatenate `preDefaultCase`, `defaultCase`, `postDefaultCase` auto cases = preDefaultCases; factory_.addList(cases, defaultCase); ParseNode* iter = postDefaultCases->pn_head; while (iter) { ParseNode* next = iter->pn_next; factory_.addList(cases, iter); iter = next; } - TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); - TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); + BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); + BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); return result; } /* interface TemplateElement : Node { string rawValue; } @@ -6301,17 +6435,17 @@ BinASTParser<Tok>::parseTemplateElement( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceTemplateElement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceTemplateElement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceTemplateElement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6330,17 +6464,17 @@ BinASTParser<Tok>::parseTemplateExpressi { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceTemplateExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceTemplateExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceTemplateExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6357,17 +6491,17 @@ BinASTParser<Tok>::parseThisExpression() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceThisExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceThisExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceThisExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6377,19 +6511,19 @@ BinASTParser<Tok>::parseInterfaceThisExp MOZ_TRY(tokenizer_->checkFields0(kind, fields)); if (parseContext_->isFunctionBox()) parseContext_->functionBox()->usesThis = true; TokenPos pos = tokenizer_->pos(start); ParseNode* thisName(nullptr); if (parseContext_->sc()->thisBinding() == ThisBinding::Function) - TRY_VAR(thisName, factory_.newName(cx_->names().dotThis, pos, cx_)); - - TRY_DECL(result, factory_.newThisLiteral(pos, thisName)); + BINJS_TRY_VAR(thisName, factory_.newName(cx_->names().dotThis, pos, cx_)); + + BINJS_TRY_DECL(result, factory_.newThisLiteral(pos, thisName)); return result; } /* interface ThrowStatement : Node { Expression expression; } @@ -6399,36 +6533,36 @@ BinASTParser<Tok>::parseThrowStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceThrowStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceThrowStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceThrowStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::ThrowStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Expression })); - MOZ_TRY_DECL(expression, parseExpression()); - - - TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start))); + BINJS_MOZ_TRY_DECL(expression, parseExpression()); + + + BINJS_TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start))); return result; } /* interface TryCatchStatement : Node { Block body; CatchClause catchClause; @@ -6439,17 +6573,17 @@ BinASTParser<Tok>::parseTryCatchStatemen { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceTryCatchStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceTryCatchStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceTryCatchStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6457,27 +6591,27 @@ BinASTParser<Tok>::parseInterfaceTryCatc CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Body, BinField::CatchClause })); ParseNode* body; { ParseContext::Statement stmt(parseContext_, StatementKind::Try); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); MOZ_TRY_VAR(body, parseBlock()); } - MOZ_TRY_DECL(catchClause, parseCatchClause()); - - - TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr)); + BINJS_MOZ_TRY_DECL(catchClause, parseCatchClause()); + + + BINJS_TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr)); return result; } /* interface TryFinallyStatement : Node { Block body; CatchClause? catchClause; @@ -6489,17 +6623,17 @@ BinASTParser<Tok>::parseTryFinallyStatem { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceTryFinallyStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceTryFinallyStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceTryFinallyStatement(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6507,36 +6641,36 @@ BinASTParser<Tok>::parseInterfaceTryFina CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Body, BinField::CatchClause, BinField::Finalizer })); ParseNode* body; { ParseContext::Statement stmt(parseContext_, StatementKind::Try); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); MOZ_TRY_VAR(body, parseBlock()); } - MOZ_TRY_DECL(catchClause, parseOptionalCatchClause()); + BINJS_MOZ_TRY_DECL(catchClause, parseOptionalCatchClause()); ParseNode* finalizer; { ParseContext::Statement stmt(parseContext_, StatementKind::Finally); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); MOZ_TRY_VAR(finalizer, parseBlock()); } - TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer)); + BINJS_TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer)); return result; } /* interface UnaryExpression : Node { UnaryOperator operator; Expression operand; @@ -6547,38 +6681,38 @@ BinASTParser<Tok>::parseUnaryExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceUnaryExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceUnaryExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceUnaryExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::UnaryExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Operand })); - MOZ_TRY_DECL(operator_, parseUnaryOperator()); - - - - - MOZ_TRY_DECL(operand, parseExpression()); + BINJS_MOZ_TRY_DECL(operator_, parseUnaryOperator()); + + + + + BINJS_MOZ_TRY_DECL(operand, parseExpression()); ParseNodeKind pnk; switch (operator_) { case UnaryOperator::Minus: pnk = ParseNodeKind::Neg; break; case UnaryOperator::Plus: @@ -6613,17 +6747,17 @@ BinASTParser<Tok>::parseInterfaceUnaryEx pnk = ParseNodeKind::DeleteElem; break; default: pnk = ParseNodeKind::DeleteExpr; } break; } } - TRY_DECL(result, factory_.newUnary(pnk, start, operand)); + BINJS_TRY_DECL(result, factory_.newUnary(pnk, start, operand)); return result; } /* interface UpdateExpression : Node { bool isPrefix; UpdateOperator operator; @@ -6635,57 +6769,57 @@ BinASTParser<Tok>::parseUpdateExpression { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceUpdateExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceUpdateExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceUpdateExpression(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::UpdateExpression); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsPrefix, BinField::Operator, BinField::Operand })); - MOZ_TRY_DECL(isPrefix, tokenizer_->readBool()); - - - - - MOZ_TRY_DECL(operator_, parseUpdateOperator()); - - - - - MOZ_TRY_DECL(operand, parseSimpleAssignmentTarget()); + BINJS_MOZ_TRY_DECL(isPrefix, tokenizer_->readBool()); + + + + + BINJS_MOZ_TRY_DECL(operator_, parseUpdateOperator()); + + + + + BINJS_MOZ_TRY_DECL(operand, parseSimpleAssignmentTarget()); ParseNodeKind pnk; switch (operator_) { case UpdateOperator::Incr: pnk = isPrefix ? ParseNodeKind::PreIncrement : ParseNodeKind::PostIncrement; break; case UpdateOperator::Decr: pnk = isPrefix ? ParseNodeKind::PreDecrement : ParseNodeKind::PostDecrement; break; } - TRY_DECL(result, factory_.newUnary(pnk, start, operand)); + BINJS_TRY_DECL(result, factory_.newUnary(pnk, start, operand)); return result; } /* interface VariableDeclaration : Node { VariableDeclarationKind kind; FrozenArray<VariableDeclarator> declarators; @@ -6696,39 +6830,39 @@ BinASTParser<Tok>::parseVariableDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceVariableDeclaration(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceVariableDeclaration(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::VariableDeclaration); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Kind, BinField::Declarators })); AutoVariableDeclarationKind kindGuard(this); - MOZ_TRY_DECL(kind_, parseVariableDeclarationKind()); + BINJS_MOZ_TRY_DECL(kind_, parseVariableDeclarationKind()); // Restored by `kindGuard`. variableDeclarationKind_ = kind_; - MOZ_TRY_DECL(declarators, parseListOfVariableDeclarator()); + BINJS_MOZ_TRY_DECL(declarators, parseListOfVariableDeclarator()); // By specification, the list may not be empty. if (declarators->pn_count == 0) return raiseEmpty("VariableDeclaration"); ParseNodeKind pnk; switch (kind_) { @@ -6759,57 +6893,57 @@ BinASTParser<Tok>::parseVariableDeclarat { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceVariableDeclarator(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceVariableDeclarator(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceVariableDeclarator(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::VariableDeclarator); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Binding, BinField::Init })); - MOZ_TRY_DECL(binding, parseBinding()); - - - - - MOZ_TRY_DECL(init, parseOptionalExpression()); + BINJS_MOZ_TRY_DECL(binding, parseBinding()); + + + + + BINJS_MOZ_TRY_DECL(init, parseOptionalExpression()); ParseNode* result; if (binding->isKind(ParseNodeKind::Name)) { // `var foo [= bar]`` MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName())); - TRY_VAR(result, factory_.newName(binding->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_VAR(result, factory_.newName(binding->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_)); if (init) result->pn_expr = init; } else { // `var pattern = bar` if (!init) { // Here, `init` is required. return raiseMissingField("VariableDeclarator (with non-trivial pattern)", BinField::Init); } MOZ_CRASH("Unimplemented: AssertedScope check for BindingPattern variable declaration"); - TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, binding, init)); + BINJS_TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, binding, init)); } return result; } /* interface WhileStatement : Node { Expression test; @@ -6821,41 +6955,41 @@ BinASTParser<Tok>::parseWhileStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceWhileStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceWhileStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceWhileStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::WhileStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Body })); ParseContext::Statement stmt(parseContext_, StatementKind::WhileLoop); - MOZ_TRY_DECL(test, parseExpression()); - - - - - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(result, factory_.newWhileStatement(start, test, body)); + BINJS_MOZ_TRY_DECL(test, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(result, factory_.newWhileStatement(start, test, body)); return result; } /* interface WithStatement : Node { Expression object; Statement body; @@ -6866,41 +7000,41 @@ BinASTParser<Tok>::parseWithStatement() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceWithStatement(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceWithStatement(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceWithStatement(const size_t start, const BinKind kind, const BinFields& fields) { MOZ_ASSERT(kind == BinKind::WithStatement); CheckRecursionLimit(cx_); MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Body })); - MOZ_TRY_DECL(object, parseExpression()); - - - - - MOZ_TRY_DECL(body, parseStatement()); - - - TRY_DECL(result, factory_.newWithStatement(start, object, body)); + BINJS_MOZ_TRY_DECL(object, parseExpression()); + + + + + BINJS_MOZ_TRY_DECL(body, parseStatement()); + + + BINJS_TRY_DECL(result, factory_.newWithStatement(start, object, body)); return result; } /* interface YieldExpression : Node { Expression? expression; } @@ -6910,17 +7044,17 @@ BinASTParser<Tok>::parseYieldExpression( { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceYieldExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceYieldExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceYieldExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6938,17 +7072,17 @@ BinASTParser<Tok>::parseYieldStarExpress { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); const auto start = tokenizer_->offset(); - MOZ_TRY_DECL(result, parseInterfaceYieldStarExpression(start, kind, fields)); + BINJS_MOZ_TRY_DECL(result, parseInterfaceYieldStarExpression(start, kind, fields)); MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseInterfaceYieldStarExpression(const size_t start, const BinKind kind, const BinFields& fields) { @@ -6985,17 +7119,17 @@ enum BinaryOperator { "/", "%", "**" }; */ template<typename Tok> JS::Result<typename BinASTParser<Tok>::BinaryOperator> BinASTParser<Tok>::parseBinaryOperator() { - MOZ_TRY_DECL(variant, tokenizer_->readVariant()); + BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { case BinVariant::BinaryOperatorComma: return BinaryOperator::Comma; case BinVariant::BinaryOperatorLogicalOr: return BinaryOperator::LogicalOr; case BinVariant::BinaryOperatorLogicalAnd: return BinaryOperator::LogicalAnd; @@ -7062,17 +7196,17 @@ enum CompoundAssignmentOperator { "|=", "^=", "&=" }; */ template<typename Tok> JS::Result<typename BinASTParser<Tok>::CompoundAssignmentOperator> BinASTParser<Tok>::parseCompoundAssignmentOperator() { - MOZ_TRY_DECL(variant, tokenizer_->readVariant()); + BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { case BinVariant::CompoundAssignmentOperatorPlusAssign: return CompoundAssignmentOperator::PlusAssign; case BinVariant::CompoundAssignmentOperatorMinusAssign: return CompoundAssignmentOperator::MinusAssign; case BinVariant::CompoundAssignmentOperatorMulAssign: return CompoundAssignmentOperator::MulAssign; @@ -7108,17 +7242,17 @@ enum UnaryOperator { "typeof", "void", "delete" }; */ template<typename Tok> JS::Result<typename BinASTParser<Tok>::UnaryOperator> BinASTParser<Tok>::parseUnaryOperator() { - MOZ_TRY_DECL(variant, tokenizer_->readVariant()); + BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { case BinVariant::BinaryOperatorOrUnaryOperatorPlus: return UnaryOperator::Plus; case BinVariant::BinaryOperatorOrUnaryOperatorMinus: return UnaryOperator::Minus; case BinVariant::UnaryOperatorNot: return UnaryOperator::Not; @@ -7139,17 +7273,17 @@ BinASTParser<Tok>::parseUnaryOperator() enum UpdateOperator { "++", "--" }; */ template<typename Tok> JS::Result<typename BinASTParser<Tok>::UpdateOperator> BinASTParser<Tok>::parseUpdateOperator() { - MOZ_TRY_DECL(variant, tokenizer_->readVariant()); + BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { case BinVariant::UpdateOperatorIncr: return UpdateOperator::Incr; case BinVariant::UpdateOperatorDecr: return UpdateOperator::Decr; default: return raiseInvalidVariant("UpdateOperator", variant); @@ -7161,17 +7295,17 @@ enum VariableDeclarationKind { "var", "let", "const" }; */ template<typename Tok> JS::Result<typename BinASTParser<Tok>::VariableDeclarationKind> BinASTParser<Tok>::parseVariableDeclarationKind() { - MOZ_TRY_DECL(variant, tokenizer_->readVariant()); + BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { case BinVariant::VariableDeclarationKindVar: return VariableDeclarationKind::Var; case BinVariant::VariableDeclarationKindLet: return VariableDeclarationKind::Let; case BinVariant::VariableDeclarationKindConst: return VariableDeclarationKind::Const; @@ -7187,20 +7321,20 @@ BinASTParser<Tok>::parseVariableDeclarat template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseArguments() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newList(ParseNodeKind::ParamsBody, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newList(ParseNodeKind::ParamsBody, tokenizer_->pos(start))); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseSpreadElementOrExpression()); + BINJS_MOZ_TRY_DECL(item, parseSpreadElementOrExpression()); factory_.addList(/* list = */ result, /* child = */ item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> @@ -7230,20 +7364,20 @@ BinASTParser<Tok>::parseListOfClassEleme template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfDirective() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseDirective()); + BINJS_MOZ_TRY_DECL(item, parseDirective()); factory_.addStatementToList(result, item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> @@ -7285,20 +7419,20 @@ BinASTParser<Tok>::parseListOfImportSpec template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfObjectProperty() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newObjectLiteral(start)); + BINJS_TRY_DECL(result, factory_.newObjectLiteral(start)); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseObjectProperty()); + BINJS_MOZ_TRY_DECL(item, parseObjectProperty()); result->appendWithoutOrderAssumption(item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> @@ -7310,24 +7444,24 @@ BinASTParser<Tok>::parseListOfOptionalBi template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfOptionalSpreadElementOrExpression() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newArrayLiteral(start)); + BINJS_TRY_DECL(result, factory_.newArrayLiteral(start)); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseOptionalSpreadElementOrExpression()); + BINJS_MOZ_TRY_DECL(item, parseOptionalSpreadElementOrExpression()); if (item) factory_.addArrayElement(result, item); // Infallible. else - TRY(factory_.addElision(result, tokenizer_->pos(start))); + BINJS_TRY(factory_.addElision(result, tokenizer_->pos(start))); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfParameter() @@ -7335,75 +7469,75 @@ BinASTParser<Tok>::parseListOfParameter( uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); ParseNode* result = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start)); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseParameter()); + BINJS_MOZ_TRY_DECL(item, parseParameter()); factory_.addList(/* list = */ result, /* item = */ item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfStatement() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseStatement()); + BINJS_MOZ_TRY_DECL(item, parseStatement()); factory_.addStatementToList(result, item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfSwitchCase() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseSwitchCase()); + BINJS_MOZ_TRY_DECL(item, parseSwitchCase()); factory_.addCaseStatementToList(result, item); } MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseListOfVariableDeclarator() { uint32_t length; AutoList guard(*tokenizer_); const auto start = tokenizer_->offset(); MOZ_TRY(tokenizer_->enterList(length, guard)); - TRY_DECL(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/, + BINJS_TRY_DECL(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/, tokenizer_->pos(start))); for (uint32_t i = 0; i < length; ++i) { - MOZ_TRY_DECL(item, parseVariableDeclarator()); + BINJS_MOZ_TRY_DECL(item, parseVariableDeclarator()); result->appendWithoutOrderAssumption(item); } MOZ_TRY(guard.done()); return result; } @@ -7586,33 +7720,23 @@ BinASTParser<Tok>::parseOptionalExpressi MOZ_TRY(guard.done()); return result; } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseOptionalIdentifierName() { - MOZ_TRY_DECL(result, tokenizer_->readMaybeAtom()); - - - return raiseError("FIXME: Not implemented yet (OptionalIdentifierName)"); - } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseOptionalLabel() { - MOZ_TRY_DECL(result, tokenizer_->readMaybeAtom()); - - - return raiseError("FIXME: Not implemented yet (OptionalLabel)"); - } template<typename Tok> JS::Result<ParseNode*> BinASTParser<Tok>::parseOptionalSpreadElementOrExpression() { BinKind kind; BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); @@ -7675,15 +7799,8 @@ BinASTParser<Tok>::parseOptionalVariable // Force class instantiation. // This ensures that the symbols are built, without having to export all our // code (and its baggage of #include and macros) in the header. template class BinASTParser<BinTokenReaderMultipart>; template class BinASTParser<BinTokenReaderTester>; } // namespace frontend } // namespace js - -#undef TRY -#undef TRY_VAR -#undef TRY_DECL -#undef TRY_EMPL -#undef MOZ_TRY_EMPLACE -#undef MOZ_TRY_DECL
--- a/js/src/frontend/BinSource-auto.h +++ b/js/src/frontend/BinSource-auto.h @@ -78,25 +78,25 @@ enum class VariableDeclarationKind { Const /* "const" */ }; // ----- Sums of interfaces (by lexicographical order) // Implementations are autogenerated // `ParseNode*` may never be nullptr -JS::Result<ParseNode*> parseAssignmentTarget();JS::Result<ParseNode*> parseAssignmentTargetOrAssignmentTargetWithInitializer();JS::Result<ParseNode*> parseAssignmentTargetPattern();JS::Result<ParseNode*> parseAssignmentTargetProperty();JS::Result<ParseNode*> parseBinding();JS::Result<ParseNode*> parseBindingOrBindingWithInitializer();JS::Result<ParseNode*> parseBindingPattern();JS::Result<ParseNode*> parseBindingProperty();JS::Result<ParseNode*> parseExportDeclaration();JS::Result<ParseNode*> parseExpression();JS::Result<ParseNode*> parseExpressionOrSuper();JS::Result<ParseNode*> parseExpressionOrTemplateElement();JS::Result<ParseNode*> parseForInOfBindingOrAssignmentTarget();JS::Result<ParseNode*> parseFunctionBodyOrExpression();JS::Result<ParseNode*> parseFunctionDeclarationOrClassDeclarationOrExpression();JS::Result<ParseNode*> parseFunctionDeclarationOrClassDeclarationOrVariableDeclaration();JS::Result<ParseNode*> parseImportDeclaration();JS::Result<ParseNode*> parseImportDeclarationOrExportDeclarationOrStatement();JS::Result<ParseNode*> parseIterationStatement();JS::Result<ParseNode*> parseLiteral();JS::Result<ParseNode*> parseMethodDefinition();JS::Result<ParseNode*> parseObjectProperty();JS::Result<ParseNode*> parseParameter();JS::Result<ParseNode*> parseProgram();JS::Result<ParseNode*> parsePropertyName();JS::Result<ParseNode*> parseSimpleAssignmentTarget();JS::Result<ParseNode*> parseSpreadElementOrExpression();JS::Result<ParseNode*> parseStatement();JS::Result<ParseNode*> parseVariableDeclarationOrExpression();JS::Result<ParseNode*> parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseArrowExpression();JS::Result<ParseNode*> parseAssignmentTarget();JS::Result<ParseNode*> parseAssignmentTargetOrAssignmentTargetWithInitializer();JS::Result<ParseNode*> parseAssignmentTargetPattern();JS::Result<ParseNode*> parseAssignmentTargetProperty();JS::Result<ParseNode*> parseBinding();JS::Result<ParseNode*> parseBindingOrBindingWithInitializer();JS::Result<ParseNode*> parseBindingPattern();JS::Result<ParseNode*> parseBindingProperty();JS::Result<ParseNode*> parseExportDeclaration();JS::Result<ParseNode*> parseExpression();JS::Result<ParseNode*> parseExpressionOrSuper();JS::Result<ParseNode*> parseExpressionOrTemplateElement();JS::Result<ParseNode*> parseForInOfBindingOrAssignmentTarget();JS::Result<ParseNode*> parseFunctionBodyOrExpression();JS::Result<ParseNode*> parseFunctionDeclaration();JS::Result<ParseNode*> parseFunctionDeclarationOrClassDeclarationOrExpression();JS::Result<ParseNode*> parseFunctionDeclarationOrClassDeclarationOrVariableDeclaration();JS::Result<ParseNode*> parseFunctionExpression();JS::Result<ParseNode*> parseGetter();JS::Result<ParseNode*> parseImportDeclaration();JS::Result<ParseNode*> parseImportDeclarationOrExportDeclarationOrStatement();JS::Result<ParseNode*> parseIterationStatement();JS::Result<ParseNode*> parseLiteral();JS::Result<ParseNode*> parseMethod();JS::Result<ParseNode*> parseMethodDefinition();JS::Result<ParseNode*> parseObjectProperty();JS::Result<ParseNode*> parseParameter();JS::Result<ParseNode*> parseProgram();JS::Result<ParseNode*> parsePropertyName();JS::Result<ParseNode*> parseSetter();JS::Result<ParseNode*> parseSimpleAssignmentTarget();JS::Result<ParseNode*> parseSpreadElementOrExpression();JS::Result<ParseNode*> parseStatement();JS::Result<ParseNode*> parseVariableDeclarationOrExpression();JS::Result<ParseNode*> parseSumArrowExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumGetter(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumMethod(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumSetter(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields);JS::Result<ParseNode*> parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields); // ----- Interfaces (by lexicographical order) // Implementations are autogenerated // `ParseNode*` may never be nullptr +JS::Result<ParseNode*> parseNull(); JS::Result<ParseNode*> parseArrayAssignmentTarget(); JS::Result<ParseNode*> parseArrayBinding(); JS::Result<ParseNode*> parseArrayExpression(); -JS::Result<ParseNode*> parseArrowExpression(); JS::Result<Ok> parseAssertedBlockScope(); JS::Result<Ok> parseAssertedParameterScope(); JS::Result<Ok> parseAssertedVarScope(); JS::Result<ParseNode*> parseAssignmentExpression(); JS::Result<ParseNode*> parseAssignmentTargetIdentifier(); JS::Result<ParseNode*> parseAssignmentTargetPropertyIdentifier(); JS::Result<ParseNode*> parseAssignmentTargetPropertyProperty(); JS::Result<ParseNode*> parseAssignmentTargetWithInitializer(); @@ -118,58 +118,65 @@ JS::Result<ParseNode*> parseComputedMemb JS::Result<ParseNode*> parseComputedMemberExpression(); JS::Result<ParseNode*> parseComputedPropertyName(); JS::Result<ParseNode*> parseConditionalExpression(); JS::Result<ParseNode*> parseContinueStatement(); JS::Result<ParseNode*> parseDataProperty(); JS::Result<ParseNode*> parseDebuggerStatement(); JS::Result<ParseNode*> parseDirective(); JS::Result<ParseNode*> parseDoWhileStatement(); +JS::Result<ParseNode*> parseEagerArrowExpression(); +JS::Result<ParseNode*> parseEagerFunctionDeclaration(); +JS::Result<ParseNode*> parseEagerFunctionExpression(); +JS::Result<ParseNode*> parseEagerGetter(); +JS::Result<ParseNode*> parseEagerMethod(); +JS::Result<ParseNode*> parseEagerSetter(); JS::Result<ParseNode*> parseEmptyStatement(); JS::Result<ParseNode*> parseExport(); JS::Result<ParseNode*> parseExportAllFrom(); JS::Result<ParseNode*> parseExportDefault(); JS::Result<ParseNode*> parseExportFrom(); JS::Result<ParseNode*> parseExportFromSpecifier(); JS::Result<ParseNode*> parseExportLocalSpecifier(); JS::Result<ParseNode*> parseExportLocals(); JS::Result<ParseNode*> parseExpressionStatement(); JS::Result<ParseNode*> parseForInOfBinding(); JS::Result<ParseNode*> parseForInStatement(); JS::Result<ParseNode*> parseForOfStatement(); JS::Result<ParseNode*> parseForStatement(); JS::Result<ParseNode*> parseFormalParameters(); JS::Result<ParseNode*> parseFunctionBody(); -JS::Result<ParseNode*> parseFunctionDeclaration(); -JS::Result<ParseNode*> parseFunctionExpression(); -JS::Result<ParseNode*> parseGetter(); JS::Result<ParseNode*> parseIdentifierExpression(); JS::Result<ParseNode*> parseIfStatement(); JS::Result<ParseNode*> parseImport(); JS::Result<ParseNode*> parseImportNamespace(); JS::Result<ParseNode*> parseImportSpecifier(); JS::Result<ParseNode*> parseLabelledStatement(); JS::Result<ParseNode*> parseLiteralBooleanExpression(); JS::Result<ParseNode*> parseLiteralInfinityExpression(); JS::Result<ParseNode*> parseLiteralNullExpression(); JS::Result<ParseNode*> parseLiteralNumericExpression(); JS::Result<ParseNode*> parseLiteralPropertyName(); JS::Result<ParseNode*> parseLiteralRegExpExpression(); JS::Result<ParseNode*> parseLiteralStringExpression(); -JS::Result<ParseNode*> parseMethod(); JS::Result<ParseNode*> parseModule(); JS::Result<ParseNode*> parseNewExpression(); JS::Result<ParseNode*> parseNewTargetExpression(); JS::Result<ParseNode*> parseObjectAssignmentTarget(); JS::Result<ParseNode*> parseObjectBinding(); JS::Result<ParseNode*> parseObjectExpression(); JS::Result<ParseNode*> parseReturnStatement(); JS::Result<ParseNode*> parseScript(); -JS::Result<ParseNode*> parseSetter(); JS::Result<ParseNode*> parseShorthandProperty(); +JS::Result<ParseNode*> parseSkippableArrowExpression(); +JS::Result<ParseNode*> parseSkippableFunctionDeclaration(); +JS::Result<ParseNode*> parseSkippableFunctionExpression(); +JS::Result<ParseNode*> parseSkippableGetter(); +JS::Result<ParseNode*> parseSkippableMethod(); +JS::Result<ParseNode*> parseSkippableSetter(); JS::Result<ParseNode*> parseSpreadElement(); JS::Result<ParseNode*> parseStaticMemberAssignmentTarget(); JS::Result<ParseNode*> parseStaticMemberExpression(); JS::Result<ParseNode*> parseSuper(); JS::Result<ParseNode*> parseSwitchCase(); JS::Result<ParseNode*> parseSwitchDefault(); JS::Result<ParseNode*> parseSwitchStatement(); JS::Result<ParseNode*> parseSwitchStatementWithDefault(); @@ -182,21 +189,20 @@ JS::Result<ParseNode*> parseTryFinallySt JS::Result<ParseNode*> parseUnaryExpression(); JS::Result<ParseNode*> parseUpdateExpression(); JS::Result<ParseNode*> parseVariableDeclaration(); JS::Result<ParseNode*> parseVariableDeclarator(); JS::Result<ParseNode*> parseWhileStatement(); JS::Result<ParseNode*> parseWithStatement(); JS::Result<ParseNode*> parseYieldExpression(); JS::Result<ParseNode*> parseYieldStarExpression(); -JS::Result<ParseNode*> parseNull(); +JS::Result<ParseNode*> parseInterfaceNull(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceArrayAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceArrayBinding(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceArrowExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<Ok> parseInterfaceAssertedBlockScope(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<Ok> parseInterfaceAssertedParameterScope(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<Ok> parseInterfaceAssertedVarScope(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceAssignmentTargetIdentifier(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields); @@ -218,58 +224,65 @@ JS::Result<ParseNode*> parseInterfaceCom JS::Result<ParseNode*> parseInterfaceComputedMemberExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceComputedPropertyName(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceContinueStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceDataProperty(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceDebuggerStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceDirective(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceDoWhileStatement(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerArrowExpression(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerGetter(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerMethod(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceEagerSetter(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceEmptyStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExport(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportAllFrom(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportDefault(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportFrom(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportFromSpecifier(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportLocalSpecifier(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExportLocals(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceForInOfBinding(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceForInStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceForOfStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceForStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceFormalParameters(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceFunctionBody(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceGetter(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceIdentifierExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceIfStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceImport(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceImportNamespace(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceImportSpecifier(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLabelledStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralInfinityExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralNumericExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralPropertyName(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralRegExpExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceLiteralStringExpression(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceMethod(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceModule(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceNewTargetExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceObjectAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceObjectBinding(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceReturnStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceScript(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceSetter(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceShorthandProperty(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableArrowExpression(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableGetter(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableMethod(const size_t start, const BinKind kind, const BinFields& fields); +JS::Result<ParseNode*> parseInterfaceSkippableSetter(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSpreadElement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceStaticMemberExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSuper(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSwitchCase(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSwitchDefault(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSwitchStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceSwitchStatementWithDefault(const size_t start, const BinKind kind, const BinFields& fields); @@ -282,26 +295,25 @@ JS::Result<ParseNode*> parseInterfaceTry JS::Result<ParseNode*> parseInterfaceUnaryExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceUpdateExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceVariableDeclarator(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceWhileStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceWithStatement(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceYieldExpression(const size_t start, const BinKind kind, const BinFields& fields); JS::Result<ParseNode*> parseInterfaceYieldStarExpression(const size_t start, const BinKind kind, const BinFields& fields); -JS::Result<ParseNode*> parseInterfaceNull(const size_t start, const BinKind kind, const BinFields& fields); // ----- String enums (by lexicographical order) // Implementations are autogenerated -JS::Result<BinASTParser::BinaryOperator> parseBinaryOperator(); -JS::Result<BinASTParser::CompoundAssignmentOperator> parseCompoundAssignmentOperator(); -JS::Result<BinASTParser::UnaryOperator> parseUnaryOperator(); -JS::Result<BinASTParser::UpdateOperator> parseUpdateOperator(); -JS::Result<BinASTParser::VariableDeclarationKind> parseVariableDeclarationKind(); +JS::Result<typename BinASTParser<Tok>::BinaryOperator> parseBinaryOperator(); +JS::Result<typename BinASTParser<Tok>::CompoundAssignmentOperator> parseCompoundAssignmentOperator(); +JS::Result<typename BinASTParser<Tok>::UnaryOperator> parseUnaryOperator(); +JS::Result<typename BinASTParser<Tok>::UpdateOperator> parseUpdateOperator(); +JS::Result<typename BinASTParser<Tok>::VariableDeclarationKind> parseVariableDeclarationKind(); // ----- Lists (by lexicographical order) // Implementations are autogenerated JS::Result<ParseNode*> parseArguments(); JS::Result<ParseNode*> parseListOfAssignmentTargetOrAssignmentTargetWithInitializer(); JS::Result<ParseNode*> parseListOfAssignmentTargetProperty(); JS::Result<ParseNode*> parseListOfBindingProperty();
--- a/js/src/frontend/BinSource.cpp +++ b/js/src/frontend/BinSource.cpp @@ -8,16 +8,17 @@ #include "mozilla/ArrayUtils.h" #include "mozilla/Casting.h" #include "mozilla/Maybe.h" #include "mozilla/Move.h" #include "mozilla/PodOperations.h" #include "mozilla/Vector.h" +#include "frontend/BinSource-macros.h" #include "frontend/BinTokenReaderTester.h" #include "frontend/FullParseHandler.h" #include "frontend/Parser.h" #include "frontend/SharedContext.h" #include "vm/RegExpObject.h" #include "frontend/ParseContext-inl.h" @@ -63,258 +64,214 @@ // is therefore unsafe. // // # About directives // // Currently, directives are ignored and treated as regular strings. // // They should be treated lazily (whenever we open a subscope), like bindings. -// Evaluate an expression, checking that the result is not 0. -// -// Throw `cx->alreadyReportedError()` if it returns 0/nullptr. -#define TRY(EXPR) \ - do { \ - if (!EXPR) \ - return cx_->alreadyReportedError(); \ - } while(false) - - -#define TRY_VAR(VAR, EXPR) \ - do { \ - VAR = EXPR; \ - if (!VAR) \ - return cx_->alreadyReportedError(); \ - } while (false) - -#define TRY_DECL(VAR, EXPR) \ - auto VAR = EXPR; \ - if (!VAR) \ - return cx_->alreadyReportedError(); - -#define TRY_EMPL(VAR, EXPR) \ - do { \ - auto _tryEmplResult = EXPR; \ - if (!_tryEmplResult) \ - return cx_->alreadyReportedError(); \ - VAR.emplace(_tryEmplResult.unwrap()); \ - } while (false) - -#define MOZ_TRY_EMPLACE(VAR, EXPR) \ - do { \ - auto _tryEmplResult = EXPR; \ - if (_tryEmplResult.isErr()) \ - return ::mozilla::Err(_tryEmplResult.unwrapErr()); \ - VAR.emplace(_tryEmplResult.unwrap()); \ - } while (false) - using namespace mozilla; namespace js { namespace frontend { -using AutoList = BinTokenReaderTester::AutoList; -using AutoTaggedTuple = BinTokenReaderTester::AutoTaggedTuple; -using AutoTuple = BinTokenReaderTester::AutoTuple; -using BinFields = BinTokenReaderTester::BinFields; -using Chars = BinTokenReaderTester::Chars; -using NameBag = GCHashSet<JSString*>; -using Names = GCVector<JSString*, 8>; using UsedNamePtr = UsedNameTracker::UsedNameMap::Ptr; // ------------- Toplevel constructions -JS::Result<ParseNode*> -BinASTParser::parse(const Vector<uint8_t>& data) +template<typename Tok> JS::Result<ParseNode*> +BinASTParser<Tok>::parse(const Vector<uint8_t>& data) { return parse(data.begin(), data.length()); } -JS::Result<ParseNode*> -BinASTParser::parse(const uint8_t* start, const size_t length) +template<typename Tok> JS::Result<ParseNode*> +BinASTParser<Tok>::parse(const uint8_t* start, const size_t length) { auto result = parseAux(start, length); poison(); // Make sure that the parser is never used again accidentally. return result; } -JS::Result<ParseNode*> -BinASTParser::parseAux(const uint8_t* start, const size_t length) +template<typename Tok> JS::Result<ParseNode*> +BinASTParser<Tok>::parseAux(const uint8_t* start, const size_t length) { tokenizer_.emplace(cx_, start, length); Directives directives(options().strictOption); GlobalSharedContext globalsc(cx_, ScopeKind::Global, directives, options().extraWarningsOption); BinParseContext globalpc(cx_, this, &globalsc, /* newDirectives = */ nullptr); if (!globalpc.init()) return cx_->alreadyReportedError(); ParseContext::VarScope varScope(cx_, &globalpc, usedNames_); if (!varScope.init(&globalpc)) return cx_->alreadyReportedError(); + MOZ_TRY(tokenizer_->readHeader()); + ParseNode* result(nullptr); MOZ_TRY_VAR(result, parseProgram()); Maybe<GlobalScope::Data*> bindings = NewGlobalScopeData(cx_, varScope, alloc_, parseContext_); if (!bindings) return cx_->alreadyReportedError(); globalsc.bindings = *bindings; return result; // Magic conversion to Ok. } -JS::Result<FunctionBox*> -BinASTParser::buildFunctionBox(GeneratorKind generatorKind, FunctionAsyncKind functionAsyncKind) +template<typename Tok> JS::Result<FunctionBox*> +BinASTParser<Tok>::buildFunctionBox(GeneratorKind generatorKind, + FunctionAsyncKind functionAsyncKind, + FunctionSyntaxKind syntax) { // Allocate the function before walking down the tree. RootedFunction fun(cx_); - TRY_VAR(fun, NewFunctionWithProto(cx_, + BINJS_TRY_VAR(fun, NewFunctionWithProto(cx_, /* native = */ nullptr, /* nargs placeholder = */ 0, JSFunction::INTERPRETED_NORMAL, /* enclosingEnv = */ nullptr, /* name (placeholder) = */ nullptr, /* proto = */ nullptr, gc::AllocKind::FUNCTION, TenuredObject )); - TRY_DECL(funbox, alloc_.new_<FunctionBox>(cx_, + BINJS_TRY_DECL(funbox, alloc_.new_<FunctionBox>(cx_, traceListHead_, fun, /* toStringStart = */ 0, Directives(parseContext_), /* extraWarning = */ false, generatorKind, functionAsyncKind)); traceListHead_ = funbox; - FunctionSyntaxKind syntax = FunctionSyntaxKind::Expression; // FIXME - What if we're assigning? - // FIXME: The only thing we need to know is whether this is a - // ClassConstructor/DerivedClassConstructor funbox->initWithEnclosingParseContext(parseContext_, syntax); return funbox; } -JS::Result<ParseNode*> -BinASTParser::buildFunction(const size_t start, const BinKind kind, ParseNode* name, +template<typename Tok> JS::Result<ParseNode*> +BinASTParser<Tok>::buildFunction(const size_t start, const BinKind kind, ParseNode* name, ParseNode* params, ParseNode* body, FunctionBox* funbox) { TokenPos pos = tokenizer_->pos(start); RootedAtom atom((cx_)); if (name) - atom = name->name(); + atom = name->pn_atom; - funbox->function()->setArgCount(uint16_t(params->pn_count)); + funbox->function()->setArgCount(params ? uint16_t(params->pn_count) : 0); funbox->function()->initAtom(atom); // ParseNode represents the body as concatenated after the params. params->appendWithoutOrderAssumption(body); - TRY_DECL(result, kind == BinKind::FunctionDeclaration + BINJS_TRY_DECL(result, kind == BinKind::FunctionDeclaration ? factory_.newFunctionStatement(pos) : factory_.newFunctionExpression(pos)); factory_.setFunctionBox(result, funbox); factory_.setFunctionFormalParametersAndBody(result, params); HandlePropertyName dotThis = cx_->names().dotThis; const bool declareThis = hasUsedName(dotThis) || funbox->bindingsAccessedDynamically() || funbox->isDerivedClassConstructor(); if (declareThis) { ParseContext::Scope& funScope = parseContext_->functionScope(); ParseContext::Scope::AddDeclaredNamePtr p = funScope.lookupDeclaredNameForAdd(dotThis); MOZ_ASSERT(!p); - TRY(funScope.addDeclaredName(parseContext_, p, dotThis, DeclarationKind::Var, + BINJS_TRY(funScope.addDeclaredName(parseContext_, p, dotThis, DeclarationKind::Var, DeclaredNameInfo::npos)); funbox->setHasThisBinding(); } - TRY_DECL(bindings, + BINJS_TRY_DECL(bindings, NewFunctionScopeData(cx_, parseContext_->functionScope(), /* hasParameterExprs = */ false, alloc_, parseContext_)); funbox->functionScopeBindings().set(*bindings); return result; } -JS::Result<Ok> -BinASTParser::parseAndUpdateCapturedNames() +template<typename Tok> JS::Result<Ok> +BinASTParser<Tok>::parseAndUpdateCapturedNames() { // For the moment, we do not attempt to validate the list of captured names. AutoList guard(*tokenizer_); uint32_t length = 0; - TRY(tokenizer_->enterList(length, guard)); + MOZ_TRY(tokenizer_->enterList(length, guard)); RootedAtom name(cx_); for (uint32_t i = 0; i < length; ++i) { name = nullptr; - MOZ_TRY(readString(&name)); + MOZ_TRY_VAR(name, tokenizer_->readAtom()); } - TRY(guard.done()); + MOZ_TRY(guard.done()); return Ok(); } -JS::Result<Ok> -BinASTParser::parseAndUpdateScopeNames(ParseContext::Scope& scope, DeclarationKind kind) +template<typename Tok> JS::Result<Ok> +BinASTParser<Tok>::parseAndUpdateScopeNames(ParseContext::Scope& scope, DeclarationKind kind) { AutoList guard(*tokenizer_); uint32_t length = 0; - TRY(tokenizer_->enterList(length, guard)); + MOZ_TRY(tokenizer_->enterList(length, guard)); RootedAtom name(cx_); for (uint32_t i = 0; i < length; ++i) { name = nullptr; - MOZ_TRY(readString(&name)); + MOZ_TRY_VAR(name, tokenizer_->readAtom()); auto ptr = scope.lookupDeclaredNameForAdd(name); if (ptr) return raiseError("Variable redeclaration"); - TRY(scope.addDeclaredName(parseContext_, ptr, name.get(), kind, tokenizer_->offset())); + BINJS_TRY(scope.addDeclaredName(parseContext_, ptr, name.get(), kind, tokenizer_->offset())); } - TRY(guard.done()); + MOZ_TRY(guard.done()); return Ok(); } -JS::Result<Ok> -BinASTParser::checkBinding(JSAtom* name) +template<typename Tok> JS::Result<Ok> +BinASTParser<Tok>::checkBinding(JSAtom* name) { // Check that the variable appears in the corresponding scope. ParseContext::Scope& scope = variableDeclarationKind_ == VariableDeclarationKind::Var ? parseContext_->varScope() : *parseContext_->innermostScope(); auto ptr = scope.lookupDeclaredName(name->asPropertyName()); if (!ptr) return raiseMissingVariableInAssertedScope(name); return Ok(); } -JS::Result<ParseNode*> -BinASTParser::appendDirectivesToBody(ParseNode* body, ParseNode* directives) +template<typename Tok> JS::Result<ParseNode*> +BinASTParser<Tok>::appendDirectivesToBody(ParseNode* body, ParseNode* directives) { ParseNode* result = body; if (directives && directives->pn_count >= 1) { MOZ_ASSERT(directives->isArity(PN_LIST)); // Convert directive list to a list of strings. - TRY_DECL(prefix, factory_.newStatementList(directives->pn_head->pn_pos)); + BINJS_TRY_DECL(prefix, factory_.newStatementList(directives->pn_head->pn_pos)); for (ParseNode* iter = directives->pn_head; iter != nullptr; iter = iter->pn_next) { - TRY_DECL(statement, factory_.newExprStatement(iter, iter->pn_pos.end)); + BINJS_TRY_DECL(statement, factory_.newExprStatement(iter, iter->pn_pos.end)); prefix->appendWithoutOrderAssumption(statement); } // Prepend to the body. ParseNode* iter = body->pn_head; while (iter) { ParseNode* next = iter->pn_next; prefix->appendWithoutOrderAssumption(iter); @@ -326,214 +283,123 @@ BinASTParser::appendDirectivesToBody(Par #if defined(DEBUG) result->checkListConsistency(); #endif // defined(DEBUG) } return result; } -JS::Result<Ok> -BinASTParser::readString(MutableHandleAtom out) -{ - MOZ_ASSERT(!out); - - Maybe<Chars> string; - MOZ_TRY(readMaybeString(string)); - MOZ_ASSERT(string); - - RootedAtom atom(cx_); - TRY_VAR(atom, AtomizeUTF8Chars(cx_, (const char*)string->begin(), string->length())); - - out.set(Move(atom)); - return Ok(); -} - -JS::Result<Ok> -BinASTParser::readMaybeString(MutableHandleAtom out) -{ - MOZ_ASSERT(!out); - - Maybe<Chars> string; - MOZ_TRY(readMaybeString(string)); - if (!string) { - return Ok(); - } - - RootedAtom atom(cx_); - TRY_VAR(atom, AtomizeUTF8Chars(cx_, (const char*)string->begin(), string->length())); - - out.set(Move(atom)); - return Ok(); -} - - -JS::Result<Ok> -BinASTParser::readString(Chars& result) -{ - TRY(tokenizer_->readChars(result)); - return Ok(); -} - -JS::Result<Ok> -BinASTParser::readMaybeString(Maybe<Chars>& out) -{ - MOZ_ASSERT(out.isNothing()); - TRY(tokenizer_->readMaybeChars(out)); - return Ok(); -} - -JS::Result<double> -BinASTParser::readNumber() -{ - double result; - TRY(tokenizer_->readDouble(result)); - - return result; -} - -JS::Result<bool> -BinASTParser::readBool() -{ - bool result; - TRY(tokenizer_->readBool(result)); - - return result; -} - -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseMissingVariableInAssertedScope(JSAtom* name) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseMissingVariableInAssertedScope(JSAtom* name) { // For the moment, we don't trust inputs sufficiently to put the name // in an error message. return raiseError("Missing variable in AssertedScope"); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseMissingDirectEvalInAssertedScope() +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseMissingDirectEvalInAssertedScope() { return raiseError("Direct call to `eval` was not declared in AssertedScope"); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseInvalidKind(const char* superKind, const BinKind kind) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseInvalidKind(const char* superKind, const BinKind kind) { Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("In %s, invalid kind %s", superKind, describeBinKind(kind))); - return raiseError(out.string()); -} - -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseInvalidField(const char* kind, const BinField field) -{ - Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("In %s, invalid field '%s'", kind, describeBinField(field))); + BINJS_TRY(out.init()); + BINJS_TRY(out.printf("In %s, invalid kind %s", superKind, describeBinKind(kind))); return raiseError(out.string()); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseInvalidNumberOfFields(const BinKind kind, const uint32_t expected, const uint32_t got) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseInvalidVariant(const char* kind, const BinVariant value) { Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("In %s, invalid number of fields: expected %u, got %u", - describeBinKind(kind), expected, got)); + BINJS_TRY(out.init()); + BINJS_TRY(out.printf("In %s, invalid variant '%s'", kind, describeBinVariant(value))); + return raiseError(out.string()); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseInvalidEnum(const char* kind, const Chars& value) -{ - // We don't trust the actual chars of `value` to be properly formatted anything, so let's not use - // them anywhere. - return raiseError("Invalid enum"); -} - -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseMissingField(const char* kind, const BinField field) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseMissingField(const char* kind, const BinField field) { Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("In %s, missing field '%s'", kind, describeBinField(field))); + BINJS_TRY(out.init()); + BINJS_TRY(out.printf("In %s, missing field '%s'", kind, describeBinField(field))); return raiseError(out.string()); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseEmpty(const char* description) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseEmpty(const char* description) { Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("Empty %s", description)); + BINJS_TRY(out.init()); + BINJS_TRY(out.printf("Empty %s", description)); return raiseError(out.string()); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseOOM() +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseOOM() { - ReportOutOfMemory(cx_); - return cx_->alreadyReportedError(); + return tokenizer_->raiseOOM(); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseError(BinKind kind, const char* description) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseError(BinKind kind, const char* description) { Sprinter out(cx_); - TRY(out.init()); - TRY(out.printf("In %s, ", description)); - MOZ_ALWAYS_FALSE(tokenizer_->raiseError(out.string())); - - return cx_->alreadyReportedError(); + BINJS_TRY(out.init()); + BINJS_TRY(out.printf("In %s, ", description)); + return tokenizer_->raiseError(out.string()); } -mozilla::GenericErrorResult<JS::Error&> -BinASTParser::raiseError(const char* description) +template<typename Tok> mozilla::GenericErrorResult<JS::Error&> +BinASTParser<Tok>::raiseError(const char* description) { - MOZ_ALWAYS_FALSE(tokenizer_->raiseError(description)); - return cx_->alreadyReportedError(); + return tokenizer_->raiseError(description); } -void -BinASTParser::poison() +template<typename Tok> void +BinASTParser<Tok>::poison() { tokenizer_.reset(); } -void -BinASTParser::reportErrorNoOffsetVA(unsigned errorNumber, va_list args) +template<typename Tok> void +BinASTParser<Tok>::reportErrorNoOffsetVA(unsigned errorNumber, va_list args) { ErrorMetadata metadata; metadata.filename = getFilename(); metadata.lineNumber = 0; metadata.columnNumber = offset(); ReportCompileError(cx_, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args); } bool -BinASTParser::hasUsedName(HandlePropertyName name) +BinASTParserBase::hasUsedName(HandlePropertyName name) { if (UsedNamePtr p = usedNames_.lookup(name)) return p->value().isUsedInScript(parseContext_->scriptId()); return false; } void TraceBinParser(JSTracer* trc, AutoGCRooter* parser) { - static_cast<BinASTParser*>(parser)->trace(trc); + static_cast<BinASTParserBase*>(parser)->trace(trc); } + +// Force class instantiation. +// This ensures that the symbols are built, without having to export all our +// code (and its baggage of #include and macros) in the header. +template class BinASTParser<BinTokenReaderMultipart>; +template class BinASTParser<BinTokenReaderTester>; + } // namespace frontend } // namespace js - -// #undef everything, to avoid collisions with unified builds. - -#undef TRY -#undef TRY_VAR -#undef TRY_DECL -#undef TRY_EMPL -#undef MOZ_TRY_EMPLACE -
--- a/js/src/frontend/BinSource.h +++ b/js/src/frontend/BinSource.h @@ -11,157 +11,62 @@ * A Binary AST parser. * * At the time of this writing, this parser implements the grammar of ES5 * and trusts its input (in particular, variable declarations). */ #include "mozilla/Maybe.h" +#include "frontend/BinToken.h" +#include "frontend/BinTokenReaderMultipart.h" #include "frontend/BinTokenReaderTester.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseContext.h" #include "frontend/ParseNode.h" #include "frontend/SharedContext.h" #include "js/GCHashTable.h" #include "js/GCVector.h" #include "js/Result.h" namespace js { namespace frontend { -class BinASTParser; - -/** - * The parser for a Binary AST. - * - * By design, this parser never needs to backtrack or look ahead. Errors are not - * recoverable. - */ -class BinASTParser : private JS::AutoGCRooter, public ErrorReporter +class BinASTParserBase: private JS::AutoGCRooter { - using Tokenizer = BinTokenReaderTester; - using BinFields = Tokenizer::BinFields; - using Chars = Tokenizer::Chars; - using Names = JS::GCVector<JSString*, 8>; - public: - BinASTParser(JSContext* cx, LifoAlloc& alloc, UsedNameTracker& usedNames, const JS::ReadOnlyCompileOptions& options) + BinASTParserBase(JSContext* cx, LifoAlloc& alloc, UsedNameTracker& usedNames) : AutoGCRooter(cx, BINPARSER) - , traceListHead_(nullptr) - , options_(options) , cx_(cx) , alloc_(alloc) + , traceListHead_(nullptr) + , usedNames_(usedNames) , nodeAlloc_(cx, alloc) , keepAtoms_(cx) , parseContext_(nullptr) - , usedNames_(usedNames) , factory_(cx, alloc, nullptr, SourceKind::Binary) { - cx_->frontendCollectionPool().addActiveCompilation(); + cx->frontendCollectionPool().addActiveCompilation(); tempPoolMark_ = alloc.mark(); } - ~BinASTParser() + ~BinASTParserBase() { alloc_.release(tempPoolMark_); /* * The parser can allocate enormous amounts of memory for large functions. * Eagerly free the memory now (which otherwise won't be freed until the * next GC) to avoid unnecessary OOMs. */ alloc_.freeAllIfHugeAndUnused(); cx_->frontendCollectionPool().removeActiveCompilation(); } - - /** - * Parse a buffer, returning a node (which may be nullptr) in case of success - * or Nothing() in case of error. - * - * The instance of `ParseNode` MAY NOT survive the `BinASTParser`. Indeed, - * destruction of the `BinASTParser` will also destroy the `ParseNode`. - * - * In case of error, the parser reports the JS error. - */ - JS::Result<ParseNode*> parse(const uint8_t* start, const size_t length); - JS::Result<ParseNode*> parse(const Vector<uint8_t>& data); - - private: - MOZ_MUST_USE JS::Result<ParseNode*> parseAux(const uint8_t* start, const size_t length); - - // --- Raise errors. - // - // These methods return a (failed) JS::Result for convenience. - - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingVariableInAssertedScope(JSAtom* name); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingDirectEvalInAssertedScope(); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidKind(const char* superKind, - const BinKind kind); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidField(const char* kind, - const BinField field); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidNumberOfFields( - const BinKind kind, const uint32_t expected, const uint32_t got); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidEnum(const char* kind, - const Chars& value); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingField(const char* kind, - const BinField field); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseEmpty(const char* description); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseOOM(); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(const char* description); - MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(BinKind kind, - const char* description); - - - // Ensure that this parser will never be used again. - void poison(); - - // Auto-generated methods -#include "frontend/BinSource-auto.h" - - // --- Auxiliary parsing functions - template<size_t N> - JS::Result<Ok, JS::Error&> - checkFields(const BinKind kind, const BinFields& actual, const BinField (&expected)[N]); - JS::Result<Ok, JS::Error&> - checkFields0(const BinKind kind, const BinFields& actual); - - JS::Result<ParseNode*> - buildFunction(const size_t start, const BinKind kind, ParseNode* name, ParseNode* params, - ParseNode* body, FunctionBox* funbox); - JS::Result<FunctionBox*> - buildFunctionBox(GeneratorKind generatorKind, FunctionAsyncKind functionAsyncKind); - - // Parse full scope information to a specific var scope / let scope combination. - MOZ_MUST_USE JS::Result<Ok> parseAndUpdateScope(ParseContext::Scope& varScope, - ParseContext::Scope& letScope); - // Parse a list of names and add it to a given scope. - MOZ_MUST_USE JS::Result<Ok> parseAndUpdateScopeNames(ParseContext::Scope& scope, - DeclarationKind kind); - MOZ_MUST_USE JS::Result<Ok> parseAndUpdateCapturedNames(); - MOZ_MUST_USE JS::Result<Ok> checkBinding(JSAtom* name); - - // --- Utilities. - - MOZ_MUST_USE JS::Result<ParseNode*> appendDirectivesToBody(ParseNode* body, - ParseNode* directives); - - // Read a string - MOZ_MUST_USE JS::Result<Ok> readString(Chars& out); - MOZ_MUST_USE JS::Result<Ok> readMaybeString(Maybe<Chars>& out); - MOZ_MUST_USE JS::Result<Ok> readString(MutableHandleAtom out); - MOZ_MUST_USE JS::Result<Ok> readMaybeString(MutableHandleAtom out); - MOZ_MUST_USE JS::Result<bool> readBool(); - MOZ_MUST_USE JS::Result<double> readNumber(); - - const ReadOnlyCompileOptions& options() const override { - return this->options_; - } - + public: // Names bool hasUsedName(HandlePropertyName name); // --- GC. void trace(JSTracer* trc) { @@ -194,17 +99,139 @@ class BinASTParser : private JS::AutoGCR ParseNode* allocParseNode(size_t size) { MOZ_ASSERT(size == sizeof(ParseNode)); return static_cast<ParseNode*>(nodeAlloc_.allocNode()); } JS_DECLARE_NEW_METHODS(new_, allocParseNode, inline) + // Needs access to AutoGCRooter. + friend void TraceBinParser(JSTracer* trc, AutoGCRooter* parser); + + protected: + JSContext* cx_; + + // ---- Memory-related stuff + protected: + LifoAlloc& alloc_; + ObjectBox* traceListHead_; + UsedNameTracker& usedNames_; + private: + LifoAlloc::Mark tempPoolMark_; + ParseNodeAllocator nodeAlloc_; + + // Root atoms and objects allocated for the parse tree. + AutoKeepAtoms keepAtoms_; + + // ---- Parsing-related stuff + protected: + ParseContext* parseContext_; + FullParseHandler factory_; + + friend class BinParseContext; + +}; + +/** + * The parser for a Binary AST. + * + * By design, this parser never needs to backtrack or look ahead. Errors are not + * recoverable. + */ +template<typename Tok> +class BinASTParser : public BinASTParserBase, public ErrorReporter +{ + public: + using Tokenizer = Tok; + + using AutoList = typename Tokenizer::AutoList; + using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple; + using AutoTuple = typename Tokenizer::AutoTuple; + using BinFields = typename Tokenizer::BinFields; + using Chars = typename Tokenizer::Chars; + + public: + BinASTParser(JSContext* cx, LifoAlloc& alloc, UsedNameTracker& usedNames, const JS::ReadOnlyCompileOptions& options) + : BinASTParserBase(cx, alloc, usedNames) + , options_(options) + { + } + ~BinASTParser() + { + } + + /** + * Parse a buffer, returning a node (which may be nullptr) in case of success + * or Nothing() in case of error. + * + * The instance of `ParseNode` MAY NOT survive the `BinASTParser`. Indeed, + * destruction of the `BinASTParser` will also destroy the `ParseNode`. + * + * In case of error, the parser reports the JS error. + */ + JS::Result<ParseNode*> parse(const uint8_t* start, const size_t length); + JS::Result<ParseNode*> parse(const Vector<uint8_t>& data); + + private: + MOZ_MUST_USE JS::Result<ParseNode*> parseAux(const uint8_t* start, const size_t length); + + // --- Raise errors. + // + // These methods return a (failed) JS::Result for convenience. + + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingVariableInAssertedScope(JSAtom* name); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingDirectEvalInAssertedScope(); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidKind(const char* superKind, + const BinKind kind); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseInvalidVariant(const char* kind, + const BinVariant value); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseMissingField(const char* kind, + const BinField field); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseEmpty(const char* description); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseOOM(); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(const char* description); + MOZ_MUST_USE mozilla::GenericErrorResult<JS::Error&> raiseError(BinKind kind, + const char* description); + + + // Ensure that this parser will never be used again. + void poison(); + + // Auto-generated methods +#include "frontend/BinSource-auto.h" + + // --- Auxiliary parsing functions + JS::Result<ParseNode*> + buildFunction(const size_t start, const BinKind kind, ParseNode* name, ParseNode* params, + ParseNode* body, FunctionBox* funbox); + JS::Result<FunctionBox*> + buildFunctionBox(GeneratorKind generatorKind, FunctionAsyncKind functionAsyncKind, + FunctionSyntaxKind syntax); + + // Parse full scope information to a specific var scope / let scope combination. + MOZ_MUST_USE JS::Result<Ok> parseAndUpdateScope(ParseContext::Scope& varScope, + ParseContext::Scope& letScope); + // Parse a list of names and add it to a given scope. + MOZ_MUST_USE JS::Result<Ok> parseAndUpdateScopeNames(ParseContext::Scope& scope, + DeclarationKind kind); + MOZ_MUST_USE JS::Result<Ok> parseAndUpdateCapturedNames(); + MOZ_MUST_USE JS::Result<Ok> checkBinding(JSAtom* name); + + // --- Utilities. + + MOZ_MUST_USE JS::Result<ParseNode*> appendDirectivesToBody(ParseNode* body, + ParseNode* directives); + private: // Implement ErrorReporter + const ReadOnlyCompileOptions& options_; + + const ReadOnlyCompileOptions& options() const override { + return this->options_; + } virtual void lineAndColumnAt(size_t offset, uint32_t* line, uint32_t* column) const override { *line = 0; *column = offset; } virtual void currentLineAndColumn(uint32_t* line, uint32_t* column) const override { *line = 0; *column = offset(); @@ -218,47 +245,53 @@ class BinASTParser : private JS::AutoGCR virtual bool hasTokenizationStarted() const override { return tokenizer_.isSome(); } virtual void reportErrorNoOffsetVA(unsigned errorNumber, va_list args) override; virtual const char* getFilename() const override { return this->options_.filename(); } - ObjectBox* traceListHead_; - const ReadOnlyCompileOptions& options_; - JSContext* cx_; - LifoAlloc& alloc_; - LifoAlloc::Mark tempPoolMark_; - ParseNodeAllocator nodeAlloc_; - - // Root atoms and objects allocated for the parse tree. - AutoKeepAtoms keepAtoms_; - - // The current ParseContext, holding directives, etc. - ParseContext* parseContext_; - UsedNameTracker& usedNames_; Maybe<Tokenizer> tokenizer_; - FullParseHandler factory_; VariableDeclarationKind variableDeclarationKind_; friend class BinParseContext; friend class AutoVariableDeclarationKind; - // Needs access to AutoGCRooter. - friend void TraceBinParser(JSTracer* trc, AutoGCRooter* parser); + // Helper class: Restore field `variableDeclarationKind` upon leaving a scope. + class MOZ_RAII AutoVariableDeclarationKind { + public: + explicit AutoVariableDeclarationKind(BinASTParser<Tok>* parser + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : parser_(parser) + , kind(parser->variableDeclarationKind_) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + } + ~AutoVariableDeclarationKind() { + parser_->variableDeclarationKind_ = kind; + } + private: + BinASTParser<Tok>* parser_; + BinASTParser<Tok>::VariableDeclarationKind kind; + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER + }; }; class BinParseContext : public ParseContext { public: - BinParseContext(JSContext* cx, BinASTParser* parser, SharedContext* sc, + template<typename Tok> + BinParseContext(JSContext* cx, BinASTParser<Tok>* parser, SharedContext* sc, Directives* newDirectives) : ParseContext(cx, parser->parseContext_, sc, *parser, parser->usedNames_, newDirectives, /* isFull = */ true) { } }; +extern template class BinASTParser<BinTokenReaderMultipart>; +extern template class BinASTParser<BinTokenReaderTester>; + } // namespace frontend } // namespace js #endif // frontend_BinSource_h \ No newline at end of file
--- a/js/src/frontend/BinSource.webidl_ +++ b/js/src/frontend/BinSource.webidl_ @@ -185,16 +185,27 @@ typedef (ExportAllFrom or ExportFrom or ExportLocals or ExportDefault or Export) ExportDeclaration; typedef (ImportNamespace or Import) ImportDeclaration; +typedef (EagerFunctionDeclaration or SkippableFunctionDeclaration) FunctionDeclaration; + +typedef (EagerFunctionExpression or SkippableFunctionExpression) FunctionExpression; + +typedef (EagerMethod or SkippableMethod) Method; + +typedef (EagerGetter or SkippableGetter) Getter; + +typedef (EagerSetter or SkippableSetter) Setter; + +typedef (EagerArrowExpression or SkippableArrowExpression) ArrowExpression; // bindings interface BindingIdentifier : Node { attribute Identifier name; }; typedef (ObjectBinding or @@ -407,46 +418,58 @@ interface ExportLocalSpecifier : Node { }; // property definition // `MethodDefinition :: PropertyName ( UniqueFormalParameters ) { FunctionBody }`, // `GeneratorMethod :: * PropertyName ( UniqueFormalParameters ) { GeneratorBody }`, // `AsyncMethod :: async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }` -interface Method : Node { +interface EagerMethod : Node { // True for `AsyncMethod`, false otherwise. attribute boolean isAsync; // True for `GeneratorMethod`, false otherwise. attribute boolean isGenerator; attribute AssertedParameterScope? parameterScope; attribute AssertedVarScope? bodyScope; attribute PropertyName name; // The `UniqueFormalParameters`. attribute FormalParameters params; attribute FunctionBody body; }; +[Skippable] interface SkippableMethod : Node { + attribute EagerMethod skipped; +}; + // `get PropertyName ( ) { FunctionBody }` -interface Getter : Node { +interface EagerGetter : Node { attribute AssertedVarScope? bodyScope; attribute PropertyName name; attribute FunctionBody body; }; +[Skippable] interface SkippableGetter : Node { + attribute EagerGetter skipped; +}; + // `set PropertyName ( PropertySetParameterList ) { FunctionBody }` -interface Setter : Node { +interface EagerSetter : Node { attribute AssertedParameterScope? parameterScope; attribute AssertedVarScope? bodyScope; attribute PropertyName name; // The `PropertySetParameterList`. attribute Parameter param; attribute FunctionBody body; }; +[Skippable] interface SkippableSetter : Node { + attribute EagerSetter skipped; +}; + // `PropertyDefinition :: PropertyName : AssignmentExpression` interface DataProperty : Node { attribute PropertyName name; // The `AssignmentExpression`. attribute Expression expression; }; // `PropertyDefinition :: IdentifierReference` @@ -500,25 +523,29 @@ interface LiteralStringExpression : Node // `ArrayLiteral` interface ArrayExpression : Node { // The elements of the array literal; a null value represents an elision. attribute FrozenArray<(SpreadElement or Expression)?> elements; }; // `ArrowFunction`, // `AsyncArrowFunction` -interface ArrowExpression : Node { +interface EagerArrowExpression : Node { // True for `AsyncArrowFunction`, false otherwise. attribute boolean isAsync; attribute AssertedParameterScope? parameterScope; attribute AssertedVarScope? bodyScope; attribute FormalParameters params; attribute (FunctionBody or Expression) body; }; +[Skippable] interface SkippableArrowExpression : Node { + attribute EagerArrowExpression skipped; +}; + // `AssignmentExpression :: LeftHandSideExpression = AssignmentExpression` interface AssignmentExpression : Node { // The `LeftHandSideExpression`. attribute AssignmentTarget binding; // The `AssignmentExpression` following the `=`. attribute Expression expression; }; @@ -570,26 +597,30 @@ interface ConditionalExpression : Node { attribute Expression consequent; // The second `AssignmentExpression`. attribute Expression alternate; }; // `FunctionExpression`, // `GeneratorExpression`, // `AsyncFunctionExpression`, -interface FunctionExpression : Node { +interface EagerFunctionExpression : Node { attribute boolean isAsync; attribute boolean isGenerator; attribute AssertedParameterScope? parameterScope; attribute AssertedVarScope? bodyScope; attribute BindingIdentifier? name; attribute FormalParameters params; attribute FunctionBody body; }; +[Skippable] interface SkippableFunctionExpression : Node { + attribute EagerFunctionExpression skipped; +}; + // `IdentifierReference` interface IdentifierExpression : Node { attribute Identifier name; }; interface NewExpression : Node { attribute Expression callee; attribute Arguments arguments; @@ -813,29 +844,35 @@ interface FormalParameters : Node { attribute Binding? rest; }; interface FunctionBody : Node { attribute FrozenArray<Directive> directives; attribute FrozenArray<Statement> statements; }; + + // `FunctionDeclaration`, // `GeneratorDeclaration`, // `AsyncFunctionDeclaration` -interface FunctionDeclaration : Node { +interface EagerFunctionDeclaration : Node { attribute boolean isAsync; attribute boolean isGenerator; attribute AssertedParameterScope? parameterScope; attribute AssertedVarScope? bodyScope; attribute BindingIdentifier name; attribute FormalParameters params; attribute FunctionBody body; }; +[Skippable] interface SkippableFunctionDeclaration : Node { + attribute EagerFunctionDeclaration skipped; +}; + interface Script : Node { attribute AssertedVarScope? scope; attribute FrozenArray<Directive> directives; attribute FrozenArray<Statement> statements; }; interface SpreadElement : Node { attribute Expression expression; @@ -863,9 +900,9 @@ interface TemplateElement : Node { interface VariableDeclaration : Node { attribute VariableDeclarationKind kind; [NonEmpty] attribute FrozenArray<VariableDeclarator> declarators; }; interface VariableDeclarator : Node { attribute Binding binding; attribute Expression? init; -}; +}; \ No newline at end of file
--- a/js/src/frontend/BinSource.yaml +++ b/js/src/frontend/BinSource.yaml @@ -16,140 +16,51 @@ cpp: #include "mozilla/ArrayUtils.h" #include "mozilla/Casting.h" #include "mozilla/Maybe.h" #include "mozilla/Move.h" #include "mozilla/PodOperations.h" #include "mozilla/Vector.h" + #include "frontend/BinSource-macros.h" #include "frontend/BinSource.h" #include "frontend/BinTokenReaderTester.h" #include "frontend/FullParseHandler.h" #include "frontend/Parser.h" #include "frontend/SharedContext.h" #include "vm/RegExpObject.h" #include "frontend/ParseContext-inl.h" #include "frontend/ParseNode-inl.h" namespace js { namespace frontend { - using AutoList = BinTokenReaderTester::AutoList; - using AutoTaggedTuple = BinTokenReaderTester::AutoTaggedTuple; - using AutoTuple = BinTokenReaderTester::AutoTuple; - using BinFields = BinTokenReaderTester::BinFields; - using Chars = BinTokenReaderTester::Chars; - using NameBag = GCHashSet<JSString*>; - using Names = GCVector<JSString*, 8>; - using UsedNamePtr = UsedNameTracker::UsedNameMap::Ptr; - - // Evaluate an expression EXPR, checking that the result is not falsy. - // - // Throw `cx->alreadyReportedError()` if it returns 0/nullptr. - #define TRY(EXPR) \ - do { \ - if (!EXPR) \ - return cx_->alreadyReportedError(); \ - } while(false) - - - // Evaluate an expression EXPR, checking that the result is not falsy. - // In case of success, assign the result to VAR. - // - // Throw `cx->alreadyReportedError()` if it returns 0/nullptr. - #define TRY_VAR(VAR, EXPR) \ - do { \ - VAR = EXPR; \ - if (!VAR) \ - return cx_->alreadyReportedError(); \ - } while (false) - - // Evaluate an expression EXPR, checking that the result is not falsy. - // In case of success, assign the result to a new variable VAR. - // - // Throw `cx->alreadyReportedError()` if it returns 0/nullptr. - #define TRY_DECL(VAR, EXPR) \ - auto VAR = EXPR; \ - if (!VAR) \ - return cx_->alreadyReportedError(); - - // Evaluate an expression EXPR, checking that the result is a success. - // In case of success, unwrap and assign the result to a new variable VAR. - // - // In case of error, propagate the error. - #define MOZ_TRY_DECL(VAR, EXPR) \ - auto _##VAR = EXPR; \ - if (_##VAR.isErr()) \ - return ::mozilla::Err(_##VAR.unwrapErr()); \ - auto VAR = _##VAR.unwrap(); - - // Ensure that we are visiting the right fields. - template<size_t N> - JS::Result<Ok, JS::Error&> - BinASTParser::checkFields(const BinKind kind, const BinFields& actual, const BinField (&expected)[N]) - { - if (actual.length() != N) - return raiseInvalidNumberOfFields(kind, N, actual.length()); - - for (size_t i = 0; i < N; ++i) { - if (actual[i] != expected[i]) - return raiseInvalidField(describeBinKind(kind), actual[i]); - } - - return Ok(); - } - - // Special case for N=0, as empty arrays are not permitted in C++ - JS::Result<Ok, JS::Error&> - BinASTParser::checkFields0(const BinKind kind, const BinFields& actual) - { - if (actual.length() != 0) - return raiseInvalidNumberOfFields(kind, 0, actual.length()); - - return Ok(); - } - // Compare a bunch of `uint8_t` values (as returned by the tokenizer_) with // a string literal (and ONLY a string literal). - template<size_t N> - bool operator==(const Chars& left, const char (&right)[N]) { - return BinTokenReaderTester::equals(left, right); + template<typename Tok, size_t N> + bool operator==(const typename Tok::Chars& left, const char (&right)[N]) { + return Tok::equals(left, right); } - // Helper class: Restore field `variableDeclarationKind_` upon leaving a scope. - class MOZ_RAII AutoVariableDeclarationKind { - public: - explicit AutoVariableDeclarationKind(BinASTParser* parser - MOZ_GUARD_OBJECT_NOTIFIER_PARAM) : - parser_(parser), - kind(parser->variableDeclarationKind_) - { - MOZ_GUARD_OBJECT_NOTIFIER_INIT; - } - ~AutoVariableDeclarationKind() { - parser_->variableDeclarationKind_ = kind; - } - private: - BinASTParser* parser_; - BinASTParser::VariableDeclarationKind kind; - MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER - }; - footer: | - #undef TRY - #undef TRY_VAR - #undef TRY_DECL - #undef MOZ_TRY_DECL + // Force class instantiation. + // This ensures that the symbols are built, without having to export all our + // code (and its baggage of #include and macros) in the header. + template class BinASTParser<BinTokenReaderMultipart>; + template class BinASTParser<BinTokenReaderTester>; + } // namespace frontend } // namespace js + + hpp: # Rules for generating BinSource-class.h class: header: | /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -191,16 +102,34 @@ hpp: * * ```c++ * #define WITH_FIELD(CPP_NAME, SPEC_NAME) ... * FOR_EACH_BIN_FIELD(WITH_FIELD) * ``` * * (sorted by alphabetical order) */ + field: + doc: | + /** + * The different variants of Binary AST string enums, as per + * the specifications of Binary AST, as a single macro and + * `enum class`. + * + * Separate enum classes are also defined in BinSource-auto.h. + * + * Usage: + * + * ```c++ + * #define WITH_VARIANT(CPP_NAME, SPEC_NAME) ... + * FOR_EACH_BIN_VARIANT(WITH_VARIANT) + * ``` + * + * (sorted by alphabetical order) + */ header: | /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ @@ -248,24 +177,29 @@ hpp: */ const char* describeBinKind(const BinKind& kind); /** * Return a string describing a `BinField`. */ const char* describeBinField(const BinField& kind); + /** + * Return a string describing a `BinVariant`. + */ + const char* describeBinVariant(const BinVariant& kind); + } // namespace frontend } // namespace js #endif // frontend_BinToken_h Arguments: init: - TRY_DECL(result, factory_.newList(ParseNodeKind::ParamsBody, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newList(ParseNodeKind::ParamsBody, tokenizer_->pos(start))); append: factory_.addList(/* list = */ result, /* child = */ item); ArrayExpression: build: auto result = elements; AssertedBlockScope: @@ -307,29 +241,29 @@ AssertedVarScope: fields: varDeclaredNames: block: replace: MOZ_TRY(parseAndUpdateScopeNames(parseContext_->varScope(), DeclarationKind::Var)); AssignmentExpression: build: | - TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression)); + BINJS_TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression)); AssignmentTargetIdentifier: build: | if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); BindingIdentifier: build: | if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); BinaryExpression: build: | ParseNodeKind pnk; switch (operator_) { case BinaryOperator::Comma: pnk = ParseNodeKind::Comma; break; @@ -410,56 +344,57 @@ BinaryExpression: ParseNode* result; if (left->isKind(pnk) && pnk != ParseNodeKind::Pow /* ParseNodeKind::Pow is not left-associative */) { // Regroup left-associative operations into lists. left->appendWithoutOrderAssumption(right); result = left; } else { - TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start))); + BINJS_TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start))); list->appendWithoutOrderAssumption(left); list->appendWithoutOrderAssumption(right); result = list; } Block: init: | ParseContext::Statement stmt(parseContext_, StatementKind::Block); ParseContext::Scope currentScope(cx_, parseContext_, usedNames_); - TRY(currentScope.init(parseContext_)); + BINJS_TRY(currentScope.init(parseContext_)); build: | - TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); - TRY_DECL(result, factory_.newLexicalScope(*bindings, statements)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); + BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, statements)); BreakStatement: fields: label: block: replace: | RootedAtom label(cx_); - MOZ_TRY(readMaybeString(&label)); + MOZ_TRY_VAR(label, tokenizer_->readMaybeAtom()); - if (label && !IsIdentifier(label)) - return raiseError("Invalid identifier"); build: | if (label) { + if (!IsIdentifier(label)) + return raiseError("Invalid identifier"); + auto validity = parseContext_->checkBreakStatement(label->asPropertyName()); if (validity.isErr()) { switch (validity.unwrapErr()) { case ParseContext::BreakStatementError::ToughBreak: return raiseError(kind, "Not in a loop"); case ParseContext::BreakStatementError::LabelNotFound: return raiseError(kind, "Label not found"); } } } - TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); CallExpression: build: | auto op = JSOP_CALL; // Check for direct calls to `eval`. if (factory_.isEvalName(callee, cx_)) { if (!parseContext_->varScope().lookupDeclaredNameForAdd(callee->name()) && !parseContext_->innermostScope()->lookupDeclaredNameForAdd(callee->name())) { @@ -475,27 +410,27 @@ CallExpression: result->prepend(callee); result->setOp(op); CatchClause: init: | ParseContext::Statement stmt(parseContext_, StatementKind::Catch); ParseContext::Scope currentScope(cx_, parseContext_, usedNames_); - TRY(currentScope.init(parseContext_)); + BINJS_TRY(currentScope.init(parseContext_)); build: | // Export implicit variables to the scope. // FIXME: Handle cases other than Name. MOZ_ASSERT(binding->isKind(ParseNodeKind::Name)); auto ptr = currentScope.lookupDeclaredNameForAdd(binding->name()); - TRY(currentScope.addDeclaredName(parseContext_, ptr, binding->name(), DeclarationKind::Let, start)); + BINJS_TRY(currentScope.addDeclaredName(parseContext_, ptr, binding->name(), DeclarationKind::Let, start)); - TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); - TRY_DECL(result, factory_.newLexicalScope(*bindings, body)); - TRY(factory_.setupCatchScope(result, binding, body)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_)); + BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, body)); + BINJS_TRY(factory_.setupCatchScope(result, binding, body)); CompoundAssignmentExpression: build: | ParseNodeKind pnk; switch (operator_){ case CompoundAssignmentOperator::PlusAssign: pnk = ParseNodeKind::AddAssign; break; @@ -528,304 +463,358 @@ CompoundAssignmentExpression: break; case CompoundAssignmentOperator::BitXorAssign: pnk = ParseNodeKind::BitXorAssign; break; case CompoundAssignmentOperator::BitAndAssign: pnk = ParseNodeKind::BitAndAssign; break; } - TRY_DECL(result, factory_.newAssignment(pnk, binding, expression)); + BINJS_TRY_DECL(result, factory_.newAssignment(pnk, binding, expression)); ComputedMemberAssignmentTarget: build: | - TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); + BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); ComputedMemberExpression: build: | - TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); + BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start)); ConditionalExpression: build: | - TRY_DECL(result, factory_.newConditional(test, consequent, alternate)); + BINJS_TRY_DECL(result, factory_.newConditional(test, consequent, alternate)); ContinueStatement: fields: label: block: replace: | RootedAtom label(cx_); - MOZ_TRY(readMaybeString(&label)); + MOZ_TRY_VAR(label, tokenizer_->readMaybeAtom()); - if (label && !IsIdentifier(label)) - return raiseError("ContinueStatement - Label MUST be an identifier"); build: | if (label) { + if (!IsIdentifier(label)) + return raiseError("ContinueStatement - Label MUST be an identifier"); + auto validity = parseContext_->checkContinueStatement(label ? label->asPropertyName() : nullptr); if (validity.isErr()) { switch (validity.unwrapErr()) { case ParseContext::ContinueStatementError::NotInALoop: return raiseError(kind, "Not in a loop"); case ParseContext::ContinueStatementError::LabelNotFound: return raiseError(kind, "Label not found"); } } } - TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start))); DataProperty: build: | if (!factory_.isUsableAsObjectPropertyName(name)) return raiseError("DataProperty key kind"); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None)); Directive: build: | TokenPos pos = tokenizer_->pos(start); - TRY_DECL(result, factory_.newStringLiteral(rawValue, pos)); + BINJS_TRY_DECL(result, factory_.newStringLiteral(rawValue, pos)); DoWhileStatement: init: ParseContext::Statement stmt(parseContext_, StatementKind::DoLoop); build: - TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start))); + +EagerFunctionDeclaration: + init: | + const auto syntax = FunctionSyntaxKind::Statement; + inherits: EagerFunctionExpression + +EagerFunctionExpression: + init: | + const auto syntax = FunctionSyntaxKind::Expression; + fields: + parameterScope: + before: | + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + isGenerator ? GeneratorKind::Generator + : GeneratorKind::NotGenerator, + isAsync ? FunctionAsyncKind::AsyncFunction + : FunctionAsyncKind::SyncFunction, + syntax)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + build: | + BINJS_TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_)); + BINJS_TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body)); + BINJS_MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox)); + +EagerGetter: + fields: + body: + before: | + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + GeneratorKind::NotGenerator, + FunctionAsyncKind::SyncFunction, + FunctionSyntaxKind::Getter)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + build: | + ParseNode* params = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start)); + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Getter)); + +EagerMethod: + init: | + const auto syntax = FunctionSyntaxKind::Method; + inherits: EagerFunctionExpression + build: | + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None)); + +EagerSetter: + fields: + body: + before: | + BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox( + GeneratorKind::NotGenerator, + FunctionAsyncKind::SyncFunction, + FunctionSyntaxKind::Setter)); + + // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BINJS_TRY(funpc.init()); + parseContext_->functionScope().useAsVarScope(parseContext_); + MOZ_ASSERT(parseContext_->isFunctionBox()); + + ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); + BINJS_TRY(lexicalScope.init(parseContext_)); + build: | + ParseNode* params = new_<ListNode>(ParseNodeKind::ParamsBody, param->pn_pos); + factory_.addList(params, param); + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter)); EmptyStatement: build: - TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start))); ExpressionStatement: build: - TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset())); + BINJS_TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset())); ForInOfBinding: init: AutoVariableDeclarationKind kindGuard(this); build: | // Restored by `kindGuard`. variableDeclarationKind_ = kind_; MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName())); auto pnk = kind_ == VariableDeclarationKind::Let ? ParseNodeKind::Let : ParseNodeKind::Var; - TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start))); factory_.addList(result, binding); ForInStatement: init: | ParseContext::Statement stmt(parseContext_, StatementKind::ForInLoop); // Implicit scope around the `for`, used to store `for (let x in ...)` // or `for (const x in ...)`-style declarations. Detail on the // declaration is stored as part of `scope`. ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); build: | - TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start))); - TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0)); + BINJS_TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0)); if (!scope.isEmpty()) { - TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); - TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); + BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); } FormalParameters: build: | auto result = items; if (rest) { - TRY_DECL(spread, factory_.newSpread(start, rest)); + BINJS_TRY_DECL(spread, factory_.newSpread(start, rest)); factory_.addList(result, spread); } ForStatement: init: | ParseContext::Statement stmt(parseContext_, StatementKind::ForLoop); // Implicit scope around the `for`, used to store `for (let x; ...; ...)` // or `for (const x; ...; ...)`-style declarations. Detail on the // declaration is stored as part of `BINJS_Scope`. ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); build: | - TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start))); - TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0)); + BINJS_TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0)); if (!scope.isEmpty()) { - TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); - TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); + BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_)); + BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result)); } FunctionBody: build: | - MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); - -FunctionDeclaration: - inherits: FunctionExpression + BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); -FunctionExpression: - fields: - parameterScope: - before: | - MOZ_TRY_DECL(funbox, buildFunctionBox( - isGenerator ? GeneratorKind::Generator - : GeneratorKind::NotGenerator, - isAsync ? FunctionAsyncKind::AsyncFunction - : FunctionAsyncKind::SyncFunction)); - - // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function. - BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); - TRY(funpc.init()); - parseContext_->functionScope().useAsVarScope(parseContext_); - MOZ_ASSERT(parseContext_->isFunctionBox()); - - ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_); - TRY(lexicalScope.init(parseContext_)); - build: | - TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_)); - TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body)); - MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox)); IdentifierExpression: build: | if (!IsIdentifier(name)) return raiseError("Invalid identifier"); - TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_)); IfStatement: build: | - TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate)); + BINJS_TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate)); LabelledStatement: fields: label: after: | if (!IsIdentifier(label)) return raiseError("Invalid identifier"); ParseContext::LabelStatement stmt(parseContext_, label); build: - TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start)); + BINJS_TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start)); ListOfDirective: init: - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); append: factory_.addStatementToList(result, item); ListOfObjectProperty: init: - TRY_DECL(result, factory_.newObjectLiteral(start)); + BINJS_TRY_DECL(result, factory_.newObjectLiteral(start)); ListOfOptionalSpreadElementOrExpression: init: - TRY_DECL(result, factory_.newArrayLiteral(start)); + BINJS_TRY_DECL(result, factory_.newArrayLiteral(start)); append: | if (item) factory_.addArrayElement(result, item); // Infallible. else - TRY(factory_.addElision(result, tokenizer_->pos(start))); + BINJS_TRY(factory_.addElision(result, tokenizer_->pos(start))); ListOfParameter: init: | ParseNode* result = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start)); append: factory_.addList(/* list = */ result, /* item = */ item); ListOfStatement: init: - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); append: factory_.addStatementToList(result, item); #ListOfSpreadElementOrExpression: # init: # ParseNode* result = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos()); # append: # result->appendWithoutOrderAssumption(item); ListOfSwitchCase: init: - TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start))); append: factory_.addCaseStatementToList(result, item); ListOfVariableDeclarator: init: | - TRY_DECL(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/, + BINJS_TRY_DECL(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/, tokenizer_->pos(start))); LiteralBooleanExpression: build: - TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start))); LiteralNumericExpression: build: - TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start))); LiteralNullExpression: build: - TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start))); LiteralPropertyName: build: | ParseNode* result; uint32_t index; if (value->isIndex(&index)) - TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset()))); + BINJS_TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset()))); else - TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start))); + BINJS_TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start))); LiteralRegExpExpression: fields: flags: block: - replace: + replace: | Chars flags(cx_); - MOZ_TRY(readString(flags)); + MOZ_TRY(tokenizer_->readChars(flags)); build: | RegExpFlag reflags = NoFlags; for (auto c : flags) { if (c == 'g' && !(reflags & GlobalFlag)) reflags = RegExpFlag(reflags | GlobalFlag); else if (c == 'i' && !(reflags & IgnoreCaseFlag)) reflags = RegExpFlag(reflags | IgnoreCaseFlag); else if (c == 'm' && !(reflags & MultilineFlag)) reflags = RegExpFlag(reflags | MultilineFlag); else if (c == 'y' && !(reflags & StickyFlag)) reflags = RegExpFlag(reflags | StickyFlag); else if (c == 'u' && !(reflags & UnicodeFlag)) reflags = RegExpFlag(reflags | UnicodeFlag); else - return raiseInvalidEnum("RegExpLiteral", flags); + return raiseError("Invalid regexp flags"); } Rooted<RegExpObject*> reobj(cx_); - TRY_VAR(reobj, RegExpObject::create(cx_, + BINJS_TRY_VAR(reobj, RegExpObject::create(cx_, pattern, reflags, alloc_, TenuredObject)); - TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this)); + BINJS_TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this)); LiteralStringExpression: build: - TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start))); - -Method: - inherits: FunctionExpression - build: | - MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None)); + BINJS_TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start))); NewExpression: build: | auto result = arguments; result->setKind(ParseNodeKind::New); result->prepend(callee); ObjectExpression: @@ -848,123 +837,123 @@ ReturnStatement: init: | if (!parseContext_->isFunctionBox()) { // Return statements are permitted only inside functions. return raiseInvalidKind("Toplevel Statement", kind); } parseContext_->functionBox()->usesReturn = true; build: - TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start))); Script: build: - MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); + BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives)); Setter: inherits: Method init: | const auto isAsync = false; const auto isGenerator = false; build: | - TRY_DECL(params, factory_.newList(ParseNodeKind::ParamsBody, param)); - MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter)); + BINJS_TRY_DECL(params, factory_.newList(ParseNodeKind::ParamsBody, param)); + BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter)); ShorthandProperty: build: | if (!factory_.isUsableAsObjectPropertyName(name)) - TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start))); + BINJS_TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start))); - TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None)); + BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None)); SwitchCase: build: | - TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent)); + BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent)); SwitchDefault: build: | - TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent)); + BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent)); SwitchStatement: build: | - TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); - TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); + BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); + BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); SwitchStatementWithDefault: build: | // Concatenate `preDefaultCase`, `defaultCase`, `postDefaultCase` auto cases = preDefaultCases; factory_.addList(cases, defaultCase); ParseNode* iter = postDefaultCases->pn_head; while (iter) { ParseNode* next = iter->pn_next; factory_.addList(cases, iter); iter = next; } - TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); - TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); + BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases)); + BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope)); StaticMemberAssignmentTarget: build: | - TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); + BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); StaticMemberExpression: build: | - TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); + BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start)); ThisExpression: build: | if (parseContext_->isFunctionBox()) parseContext_->functionBox()->usesThis = true; TokenPos pos = tokenizer_->pos(start); ParseNode* thisName(nullptr); if (parseContext_->sc()->thisBinding() == ThisBinding::Function) - TRY_VAR(thisName, factory_.newName(cx_->names().dotThis, pos, cx_)); + BINJS_TRY_VAR(thisName, factory_.newName(cx_->names().dotThis, pos, cx_)); - TRY_DECL(result, factory_.newThisLiteral(pos, thisName)); + BINJS_TRY_DECL(result, factory_.newThisLiteral(pos, thisName)); ThrowStatement: build: - TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start))); + BINJS_TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start))); TryCatchStatement: fields: body: block: declare: ParseNode* body; before: | ParseContext::Statement stmt(parseContext_, StatementKind::Try); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); build: - TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr)); + BINJS_TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr)); TryFinallyStatement: fields: body: block: declare: ParseNode* body; before: | ParseContext::Statement stmt(parseContext_, StatementKind::Try); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); finalizer: block: declare: ParseNode* finalizer; before: | ParseContext::Statement stmt(parseContext_, StatementKind::Finally); ParseContext::Scope scope(cx_, parseContext_, usedNames_); - TRY(scope.init(parseContext_)); + BINJS_TRY(scope.init(parseContext_)); build: - TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer)); + BINJS_TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer)); UnaryExpression: build: | ParseNodeKind pnk; switch (operator_) { case UnaryOperator::Minus: pnk = ParseNodeKind::Neg; break; @@ -1000,32 +989,32 @@ UnaryExpression: pnk = ParseNodeKind::DeleteElem; break; default: pnk = ParseNodeKind::DeleteExpr; } break; } } - TRY_DECL(result, factory_.newUnary(pnk, start, operand)); + BINJS_TRY_DECL(result, factory_.newUnary(pnk, start, operand)); UpdateExpression: build: | ParseNodeKind pnk; switch (operator_) { case UpdateOperator::Incr: pnk = isPrefix ? ParseNodeKind::PreIncrement : ParseNodeKind::PostIncrement; break; case UpdateOperator::Decr: pnk = isPrefix ? ParseNodeKind::PreDecrement : ParseNodeKind::PostDecrement; break; } - TRY_DECL(result, factory_.newUnary(pnk, start, operand)); + BINJS_TRY_DECL(result, factory_.newUnary(pnk, start, operand)); VariableDeclaration: init: AutoVariableDeclarationKind kindGuard(this); fields: kind: after: | @@ -1054,31 +1043,31 @@ VariableDeclaration: VariableDeclarator: build: | ParseNode* result; if (binding->isKind(ParseNodeKind::Name)) { // `var foo [= bar]`` MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName())); - TRY_VAR(result, factory_.newName(binding->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_)); + BINJS_TRY_VAR(result, factory_.newName(binding->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_)); if (init) result->pn_expr = init; } else { // `var pattern = bar` if (!init) { // Here, `init` is required. return raiseMissingField("VariableDeclarator (with non-trivial pattern)", BinField::Init); } MOZ_CRASH("Unimplemented: AssertedScope check for BindingPattern variable declaration"); - TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, binding, init)); + BINJS_TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, binding, init)); } WhileStatement: init: ParseContext::Statement stmt(parseContext_, StatementKind::WhileLoop); build: - TRY_DECL(result, factory_.newWhileStatement(start, test, body)); + BINJS_TRY_DECL(result, factory_.newWhileStatement(start, test, body)); WithStatement: build: - TRY_DECL(result, factory_.newWithStatement(start, object, body)); + BINJS_TRY_DECL(result, factory_.newWithStatement(start, object, body));
--- a/js/src/frontend/BinToken.cpp +++ b/js/src/frontend/BinToken.cpp @@ -1,25 +1,26 @@ /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "frontend/BinToken.h" -#include "jsapi.h" +#include "mozilla/Maybe.h" -#include "mozilla/Maybe.h" +#include <sys/types.h> + +#include "jsapi.h" #include "frontend/BinSourceRuntimeSupport.h" #include "frontend/TokenStream.h" #include "gc/Zone.h" -#include <sys/types.h> namespace js { namespace frontend { const BinaryASTSupport::CharSlice BINKIND_DESCRIPTIONS[] = { #define WITH_VARIANT(_, SPEC_NAME) BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), FOR_EACH_BIN_KIND(WITH_VARIANT) #undef WITH_VARIANT
--- a/js/src/frontend/BinToken.h +++ b/js/src/frontend/BinToken.h @@ -273,17 +273,16 @@ const size_t BINKIND_LIMIT = 183; * * (sorted by alphabetical order) */ #define FOR_EACH_BIN_FIELD(F) \ F(Offset, "_offset") \ F(Alternate, "alternate") \ F(Arguments, "arguments") \ F(Binding, "binding") \ - F(BindingScope, "bindingScope") \ F(Body, "body") \ F(BodyScope, "bodyScope") \ F(Callee, "callee") \ F(CapturedNames, "capturedNames") \ F(Cases, "cases") \ F(CatchClause, "catchClause") \ F(Consequent, "consequent") \ F(Declaration, "declaration") \ @@ -341,17 +340,17 @@ const size_t BINKIND_LIMIT = 183; enum class BinField { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_FIELD(EMIT_ENUM) #undef EMIT_ENUM }; // The number of distinct values of BinField. -const size_t BINFIELD_LIMIT = 64; +const size_t BINFIELD_LIMIT = 63; #define FOR_EACH_BIN_VARIANT(F) \ F(BinaryOperatorBitAnd, "&") \ F(BinaryOperatorBitOr, "|") \ F(BinaryOperatorBitXor, "^") \ F(BinaryOperatorComma, ",") \