diff --git a/Cargo.toml b/Cargo.toml index c63c81e3409d..3ee96b675649 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ "js/src/rust", "js/src/wasm/cranelift", "js/rust", - "js/src/frontend/binast", # Code generator. + "js/src/frontend/binsource", # Code generator. "testing/geckodriver", "toolkit/crashreporter/rust", "toolkit/library/gtest/rust", diff --git a/js/src/frontend/BinASTEnum.h b/js/src/frontend/BinASTEnum.h index 38a61f168338..b3bff35a165e 100644 --- a/js/src/frontend/BinASTEnum.h +++ b/js/src/frontend/BinASTEnum.h @@ -7,7 +7,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in -// js/src/frontend/binast/README.md. +// js/src/frontend/binsource/README.md. #ifndef frontend_BinASTEnum_h #define frontend_BinASTEnum_h diff --git a/js/src/frontend/BinASTParser.cpp b/js/src/frontend/BinASTParser.cpp index a0f7e5e76bb1..59301221523c 100644 --- a/js/src/frontend/BinASTParser.cpp +++ b/js/src/frontend/BinASTParser.cpp @@ -7,7 +7,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in -// js/src/frontend/binast/README.md. +// js/src/frontend/binsource/README.md. #include "frontend/BinASTParser.h" @@ -18,8 +18,8 @@ #include "mozilla/PodOperations.h" #include "mozilla/Vector.h" -#include "frontend/BinAST-macros.h" -#include "frontend/BinASTTokenReaderMultipart.h" +#include "frontend/BinSource-macros.h" +#include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseNode.h" #include "frontend/Parser.h" @@ -50,8 +50,8 @@ template JS::Result BinASTParser::parseAssertedMaybePositionalParameterName( AssertedScopeKind scopeKind, MutableHandle> positionalParams) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -67,21 +67,21 @@ JS::Result BinASTParser::parseAssertedMaybePositionalParameterName( template JS::Result BinASTParser::parseSumAssertedMaybePositionalParameterName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind, MutableHandle> positionalParams) { Ok result; switch (kind) { - case BinASTKind::AssertedParameterName: + case BinKind::AssertedParameterName: return raiseError( "FIXME: Not implemented yet in this preview release " "(AssertedParameterName)"); - case BinASTKind::AssertedPositionalParameterName: + case BinKind::AssertedPositionalParameterName: MOZ_TRY_VAR(result, parseInterfaceAssertedPositionalParameterName( start, kind, fields, scopeKind, positionalParams)); break; - case BinASTKind::AssertedRestParameterName: + case BinKind::AssertedRestParameterName: return raiseError( "FIXME: Not implemented yet in this preview release " "(AssertedRestParameterName)"); @@ -100,8 +100,8 @@ AssignmentTarget ::= ArrayAssignmentTarget */ template JS::Result BinASTParser::parseAssignmentTarget() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -115,26 +115,26 @@ JS::Result BinASTParser::parseAssignmentTarget() { template JS::Result BinASTParser::parseSumAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayAssignmentTarget: + case BinKind::ArrayAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields)); break; - case BinASTKind::AssignmentTargetIdentifier: + case BinKind::AssignmentTargetIdentifier: MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields)); break; - case BinASTKind::ComputedMemberAssignmentTarget: + case BinKind::ComputedMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget( start, kind, fields)); break; - case BinASTKind::ObjectAssignmentTarget: + case BinKind::ObjectAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields)); break; - case BinASTKind::StaticMemberAssignmentTarget: + case BinKind::StaticMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget( start, kind, fields)); break; @@ -151,8 +151,8 @@ Binding ::= ArrayBinding */ template JS::Result BinASTParser::parseBinding() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -166,16 +166,16 @@ JS::Result BinASTParser::parseBinding() { template JS::Result BinASTParser::parseSumBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayBinding: + case BinKind::ArrayBinding: MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields)); break; - case BinASTKind::BindingIdentifier: + case BinKind::BindingIdentifier: MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields)); break; - case BinASTKind::ObjectBinding: + case BinKind::ObjectBinding: MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields)); break; default: @@ -220,8 +220,8 @@ Expression ::= ArrayExpression */ template JS::Result BinASTParser::parseExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -235,123 +235,123 @@ JS::Result BinASTParser::parseExpression() { template JS::Result BinASTParser::parseSumExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayExpression: + case BinKind::ArrayExpression: MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields)); break; - case BinASTKind::AssignmentExpression: + case BinKind::AssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields)); break; - case BinASTKind::AwaitExpression: + case BinKind::AwaitExpression: MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields)); break; - case BinASTKind::BinaryExpression: + case BinKind::BinaryExpression: MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields)); break; - case BinASTKind::CallExpression: + case BinKind::CallExpression: MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields)); break; - case BinASTKind::ClassExpression: + case BinKind::ClassExpression: MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields)); break; - case BinASTKind::CompoundAssignmentExpression: + case BinKind::CompoundAssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression( start, kind, fields)); break; - case BinASTKind::ComputedMemberExpression: + case BinKind::ComputedMemberExpression: MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields)); break; - case BinASTKind::ConditionalExpression: + case BinKind::ConditionalExpression: MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithExpression: + case BinKind::EagerArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithFunctionBody: + case BinKind::EagerArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::EagerFunctionExpression: + case BinKind::EagerFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); break; - case BinASTKind::IdentifierExpression: + case BinKind::IdentifierExpression: MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithExpression: + case BinKind::LazyArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithFunctionBody: + case BinKind::LazyArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::LazyFunctionExpression: + case BinKind::LazyFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceLazyFunctionExpression(start, kind, fields)); break; - case BinASTKind::LiteralBooleanExpression: + case BinKind::LiteralBooleanExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); break; - case BinASTKind::LiteralInfinityExpression: + case BinKind::LiteralInfinityExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); break; - case BinASTKind::LiteralNullExpression: + case BinKind::LiteralNullExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields)); break; - case BinASTKind::LiteralNumericExpression: + case BinKind::LiteralNumericExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); break; - case BinASTKind::LiteralRegExpExpression: + case BinKind::LiteralRegExpExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); break; - case BinASTKind::LiteralStringExpression: + case BinKind::LiteralStringExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields)); break; - case BinASTKind::NewExpression: + case BinKind::NewExpression: MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields)); break; - case BinASTKind::NewTargetExpression: + case BinKind::NewTargetExpression: MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields)); break; - case BinASTKind::ObjectExpression: + case BinKind::ObjectExpression: MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields)); break; - case BinASTKind::StaticMemberExpression: + case BinKind::StaticMemberExpression: MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields)); break; - case BinASTKind::TemplateExpression: + case BinKind::TemplateExpression: MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields)); break; - case BinASTKind::ThisExpression: + case BinKind::ThisExpression: MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields)); break; - case BinASTKind::UnaryExpression: + case BinKind::UnaryExpression: MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields)); break; - case BinASTKind::UpdateExpression: + case BinKind::UpdateExpression: MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields)); break; - case BinASTKind::YieldExpression: + case BinKind::YieldExpression: MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields)); break; - case BinASTKind::YieldStarExpression: + case BinKind::YieldStarExpression: MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields)); break; @@ -398,8 +398,8 @@ ExpressionOrSuper ::= ArrayExpression */ template JS::Result BinASTParser::parseExpressionOrSuper() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -413,126 +413,126 @@ JS::Result BinASTParser::parseExpressionOrSuper() { template JS::Result BinASTParser::parseSumExpressionOrSuper( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayExpression: + case BinKind::ArrayExpression: MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields)); break; - case BinASTKind::AssignmentExpression: + case BinKind::AssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields)); break; - case BinASTKind::AwaitExpression: + case BinKind::AwaitExpression: MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields)); break; - case BinASTKind::BinaryExpression: + case BinKind::BinaryExpression: MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields)); break; - case BinASTKind::CallExpression: + case BinKind::CallExpression: MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields)); break; - case BinASTKind::ClassExpression: + case BinKind::ClassExpression: MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields)); break; - case BinASTKind::CompoundAssignmentExpression: + case BinKind::CompoundAssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression( start, kind, fields)); break; - case BinASTKind::ComputedMemberExpression: + case BinKind::ComputedMemberExpression: MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields)); break; - case BinASTKind::ConditionalExpression: + case BinKind::ConditionalExpression: MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithExpression: + case BinKind::EagerArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithFunctionBody: + case BinKind::EagerArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::EagerFunctionExpression: + case BinKind::EagerFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); break; - case BinASTKind::IdentifierExpression: + case BinKind::IdentifierExpression: MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithExpression: + case BinKind::LazyArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithFunctionBody: + case BinKind::LazyArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::LazyFunctionExpression: + case BinKind::LazyFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceLazyFunctionExpression(start, kind, fields)); break; - case BinASTKind::LiteralBooleanExpression: + case BinKind::LiteralBooleanExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); break; - case BinASTKind::LiteralInfinityExpression: + case BinKind::LiteralInfinityExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); break; - case BinASTKind::LiteralNullExpression: + case BinKind::LiteralNullExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields)); break; - case BinASTKind::LiteralNumericExpression: + case BinKind::LiteralNumericExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); break; - case BinASTKind::LiteralRegExpExpression: + case BinKind::LiteralRegExpExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); break; - case BinASTKind::LiteralStringExpression: + case BinKind::LiteralStringExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields)); break; - case BinASTKind::NewExpression: + case BinKind::NewExpression: MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields)); break; - case BinASTKind::NewTargetExpression: + case BinKind::NewTargetExpression: MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields)); break; - case BinASTKind::ObjectExpression: + case BinKind::ObjectExpression: MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields)); break; - case BinASTKind::StaticMemberExpression: + case BinKind::StaticMemberExpression: MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields)); break; - case BinASTKind::Super: + case BinKind::Super: MOZ_TRY_VAR(result, parseInterfaceSuper(start, kind, fields)); break; - case BinASTKind::TemplateExpression: + case BinKind::TemplateExpression: MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields)); break; - case BinASTKind::ThisExpression: + case BinKind::ThisExpression: MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields)); break; - case BinASTKind::UnaryExpression: + case BinKind::UnaryExpression: MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields)); break; - case BinASTKind::UpdateExpression: + case BinKind::UpdateExpression: MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields)); break; - case BinASTKind::YieldExpression: + case BinKind::YieldExpression: MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields)); break; - case BinASTKind::YieldStarExpression: + case BinKind::YieldStarExpression: MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields)); break; @@ -553,8 +553,8 @@ ForInOfBindingOrAssignmentTarget ::= ArrayAssignmentTarget template JS::Result BinASTParser::parseForInOfBindingOrAssignmentTarget() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -570,29 +570,29 @@ BinASTParser::parseForInOfBindingOrAssignmentTarget() { template JS::Result BinASTParser::parseSumForInOfBindingOrAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayAssignmentTarget: + case BinKind::ArrayAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields)); break; - case BinASTKind::AssignmentTargetIdentifier: + case BinKind::AssignmentTargetIdentifier: MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields)); break; - case BinASTKind::ComputedMemberAssignmentTarget: + case BinKind::ComputedMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget( start, kind, fields)); break; - case BinASTKind::ForInOfBinding: + case BinKind::ForInOfBinding: MOZ_TRY_VAR(result, parseInterfaceForInOfBinding(start, kind, fields)); break; - case BinASTKind::ObjectAssignmentTarget: + case BinKind::ObjectAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields)); break; - case BinASTKind::StaticMemberAssignmentTarget: + case BinKind::StaticMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget( start, kind, fields)); break; @@ -614,8 +614,8 @@ ObjectProperty ::= DataProperty */ template JS::Result BinASTParser::parseObjectProperty() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -629,31 +629,31 @@ JS::Result BinASTParser::parseObjectProperty() { template JS::Result BinASTParser::parseSumObjectProperty( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::DataProperty: + case BinKind::DataProperty: MOZ_TRY_VAR(result, parseInterfaceDataProperty(start, kind, fields)); break; - case BinASTKind::EagerGetter: + case BinKind::EagerGetter: MOZ_TRY_VAR(result, parseInterfaceEagerGetter(start, kind, fields)); break; - case BinASTKind::EagerMethod: + case BinKind::EagerMethod: MOZ_TRY_VAR(result, parseInterfaceEagerMethod(start, kind, fields)); break; - case BinASTKind::EagerSetter: + case BinKind::EagerSetter: MOZ_TRY_VAR(result, parseInterfaceEagerSetter(start, kind, fields)); break; - case BinASTKind::LazyGetter: + case BinKind::LazyGetter: MOZ_TRY_VAR(result, parseInterfaceLazyGetter(start, kind, fields)); break; - case BinASTKind::LazyMethod: + case BinKind::LazyMethod: MOZ_TRY_VAR(result, parseInterfaceLazyMethod(start, kind, fields)); break; - case BinASTKind::LazySetter: + case BinKind::LazySetter: MOZ_TRY_VAR(result, parseInterfaceLazySetter(start, kind, fields)); break; - case BinASTKind::ShorthandProperty: + case BinKind::ShorthandProperty: MOZ_TRY_VAR(result, parseInterfaceShorthandProperty(start, kind, fields)); break; default: @@ -670,8 +670,8 @@ Parameter ::= ArrayBinding */ template JS::Result BinASTParser::parseParameter() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -685,13 +685,13 @@ JS::Result BinASTParser::parseParameter() { template JS::Result BinASTParser::parseSumParameter( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayBinding: + case BinKind::ArrayBinding: MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields)); break; - case BinASTKind::BindingIdentifier: + case BinKind::BindingIdentifier: MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields)); if (!pc_->positionalFormalParameterNames().append( result->template as().atom())) { @@ -701,11 +701,11 @@ JS::Result BinASTParser::parseSumParameter( pc_->functionBox()->length++; } break; - case BinASTKind::BindingWithInitializer: + case BinKind::BindingWithInitializer: MOZ_TRY_VAR(result, parseInterfaceBindingWithInitializer(start, kind, fields)); break; - case BinASTKind::ObjectBinding: + case BinKind::ObjectBinding: MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields)); break; default: @@ -720,8 +720,8 @@ Program ::= Module */ template JS::Result BinASTParser::parseProgram() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -735,13 +735,13 @@ JS::Result BinASTParser::parseProgram() { template JS::Result BinASTParser::parseSumProgram( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::Module: + case BinKind::Module: MOZ_TRY_VAR(result, parseInterfaceModule(start, kind, fields)); break; - case BinASTKind::Script: + case BinKind::Script: MOZ_TRY_VAR(result, parseInterfaceScript(start, kind, fields)); break; default: @@ -756,8 +756,8 @@ PropertyName ::= ComputedPropertyName */ template JS::Result BinASTParser::parsePropertyName() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -771,14 +771,14 @@ JS::Result BinASTParser::parsePropertyName() { template JS::Result BinASTParser::parseSumPropertyName( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ComputedPropertyName: + case BinKind::ComputedPropertyName: MOZ_TRY_VAR(result, parseInterfaceComputedPropertyName(start, kind, fields)); break; - case BinASTKind::LiteralPropertyName: + case BinKind::LiteralPropertyName: MOZ_TRY_VAR(result, parseInterfaceLiteralPropertyName(start, kind, fields)); break; @@ -795,8 +795,8 @@ SimpleAssignmentTarget ::= AssignmentTargetIdentifier */ template JS::Result BinASTParser::parseSimpleAssignmentTarget() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -811,18 +811,18 @@ JS::Result BinASTParser::parseSimpleAssignmentTarget() { template JS::Result BinASTParser::parseSumSimpleAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::AssignmentTargetIdentifier: + case BinKind::AssignmentTargetIdentifier: MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields)); break; - case BinASTKind::ComputedMemberAssignmentTarget: + case BinKind::ComputedMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget( start, kind, fields)); break; - case BinASTKind::StaticMemberAssignmentTarget: + case BinKind::StaticMemberAssignmentTarget: MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget( start, kind, fields)); break; @@ -869,8 +869,8 @@ SpreadElementOrExpression ::= ArrayExpression */ template JS::Result BinASTParser::parseSpreadElementOrExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -885,126 +885,126 @@ JS::Result BinASTParser::parseSpreadElementOrExpression() { template JS::Result BinASTParser::parseSumSpreadElementOrExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayExpression: + case BinKind::ArrayExpression: MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields)); break; - case BinASTKind::AssignmentExpression: + case BinKind::AssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields)); break; - case BinASTKind::AwaitExpression: + case BinKind::AwaitExpression: MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields)); break; - case BinASTKind::BinaryExpression: + case BinKind::BinaryExpression: MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields)); break; - case BinASTKind::CallExpression: + case BinKind::CallExpression: MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields)); break; - case BinASTKind::ClassExpression: + case BinKind::ClassExpression: MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields)); break; - case BinASTKind::CompoundAssignmentExpression: + case BinKind::CompoundAssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression( start, kind, fields)); break; - case BinASTKind::ComputedMemberExpression: + case BinKind::ComputedMemberExpression: MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields)); break; - case BinASTKind::ConditionalExpression: + case BinKind::ConditionalExpression: MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithExpression: + case BinKind::EagerArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithFunctionBody: + case BinKind::EagerArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::EagerFunctionExpression: + case BinKind::EagerFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); break; - case BinASTKind::IdentifierExpression: + case BinKind::IdentifierExpression: MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithExpression: + case BinKind::LazyArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithFunctionBody: + case BinKind::LazyArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::LazyFunctionExpression: + case BinKind::LazyFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceLazyFunctionExpression(start, kind, fields)); break; - case BinASTKind::LiteralBooleanExpression: + case BinKind::LiteralBooleanExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); break; - case BinASTKind::LiteralInfinityExpression: + case BinKind::LiteralInfinityExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); break; - case BinASTKind::LiteralNullExpression: + case BinKind::LiteralNullExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields)); break; - case BinASTKind::LiteralNumericExpression: + case BinKind::LiteralNumericExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); break; - case BinASTKind::LiteralRegExpExpression: + case BinKind::LiteralRegExpExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); break; - case BinASTKind::LiteralStringExpression: + case BinKind::LiteralStringExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields)); break; - case BinASTKind::NewExpression: + case BinKind::NewExpression: MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields)); break; - case BinASTKind::NewTargetExpression: + case BinKind::NewTargetExpression: MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields)); break; - case BinASTKind::ObjectExpression: + case BinKind::ObjectExpression: MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields)); break; - case BinASTKind::SpreadElement: + case BinKind::SpreadElement: MOZ_TRY_VAR(result, parseInterfaceSpreadElement(start, kind, fields)); break; - case BinASTKind::StaticMemberExpression: + case BinKind::StaticMemberExpression: MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields)); break; - case BinASTKind::TemplateExpression: + case BinKind::TemplateExpression: MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields)); break; - case BinASTKind::ThisExpression: + case BinKind::ThisExpression: MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields)); break; - case BinASTKind::UnaryExpression: + case BinKind::UnaryExpression: MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields)); break; - case BinASTKind::UpdateExpression: + case BinKind::UpdateExpression: MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields)); break; - case BinASTKind::YieldExpression: + case BinKind::YieldExpression: MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields)); break; - case BinASTKind::YieldStarExpression: + case BinKind::YieldStarExpression: MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields)); break; @@ -1042,8 +1042,8 @@ Statement ::= Block */ template JS::Result BinASTParser::parseStatement() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -1057,85 +1057,85 @@ JS::Result BinASTParser::parseStatement() { template JS::Result BinASTParser::parseSumStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::Block: + case BinKind::Block: MOZ_TRY_VAR(result, parseInterfaceBlock(start, kind, fields)); break; - case BinASTKind::BreakStatement: + case BinKind::BreakStatement: MOZ_TRY_VAR(result, parseInterfaceBreakStatement(start, kind, fields)); break; - case BinASTKind::ClassDeclaration: + case BinKind::ClassDeclaration: MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields)); break; - case BinASTKind::ContinueStatement: + case BinKind::ContinueStatement: MOZ_TRY_VAR(result, parseInterfaceContinueStatement(start, kind, fields)); break; - case BinASTKind::DebuggerStatement: + case BinKind::DebuggerStatement: MOZ_TRY_VAR(result, parseInterfaceDebuggerStatement(start, kind, fields)); break; - case BinASTKind::DoWhileStatement: + case BinKind::DoWhileStatement: MOZ_TRY_VAR(result, parseInterfaceDoWhileStatement(start, kind, fields)); break; - case BinASTKind::EagerFunctionDeclaration: + case BinKind::EagerFunctionDeclaration: MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields)); break; - case BinASTKind::EmptyStatement: + case BinKind::EmptyStatement: MOZ_TRY_VAR(result, parseInterfaceEmptyStatement(start, kind, fields)); break; - case BinASTKind::ExpressionStatement: + case BinKind::ExpressionStatement: MOZ_TRY_VAR(result, parseInterfaceExpressionStatement(start, kind, fields)); break; - case BinASTKind::ForInStatement: + case BinKind::ForInStatement: MOZ_TRY_VAR(result, parseInterfaceForInStatement(start, kind, fields)); break; - case BinASTKind::ForOfStatement: + case BinKind::ForOfStatement: MOZ_TRY_VAR(result, parseInterfaceForOfStatement(start, kind, fields)); break; - case BinASTKind::ForStatement: + case BinKind::ForStatement: MOZ_TRY_VAR(result, parseInterfaceForStatement(start, kind, fields)); break; - case BinASTKind::IfStatement: + case BinKind::IfStatement: MOZ_TRY_VAR(result, parseInterfaceIfStatement(start, kind, fields)); break; - case BinASTKind::LabelledStatement: + case BinKind::LabelledStatement: MOZ_TRY_VAR(result, parseInterfaceLabelledStatement(start, kind, fields)); break; - case BinASTKind::LazyFunctionDeclaration: + case BinKind::LazyFunctionDeclaration: MOZ_TRY_VAR(result, parseInterfaceLazyFunctionDeclaration(start, kind, fields)); break; - case BinASTKind::ReturnStatement: + case BinKind::ReturnStatement: MOZ_TRY_VAR(result, parseInterfaceReturnStatement(start, kind, fields)); break; - case BinASTKind::SwitchStatement: + case BinKind::SwitchStatement: MOZ_TRY_VAR(result, parseInterfaceSwitchStatement(start, kind, fields)); break; - case BinASTKind::SwitchStatementWithDefault: + case BinKind::SwitchStatementWithDefault: MOZ_TRY_VAR(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields)); break; - case BinASTKind::ThrowStatement: + case BinKind::ThrowStatement: MOZ_TRY_VAR(result, parseInterfaceThrowStatement(start, kind, fields)); break; - case BinASTKind::TryCatchStatement: + case BinKind::TryCatchStatement: MOZ_TRY_VAR(result, parseInterfaceTryCatchStatement(start, kind, fields)); break; - case BinASTKind::TryFinallyStatement: + case BinKind::TryFinallyStatement: MOZ_TRY_VAR(result, parseInterfaceTryFinallyStatement(start, kind, fields)); break; - case BinASTKind::VariableDeclaration: + case BinKind::VariableDeclaration: MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields)); break; - case BinASTKind::WhileStatement: + case BinKind::WhileStatement: MOZ_TRY_VAR(result, parseInterfaceWhileStatement(start, kind, fields)); break; - case BinASTKind::WithStatement: + case BinKind::WithStatement: MOZ_TRY_VAR(result, parseInterfaceWithStatement(start, kind, fields)); break; default: @@ -1147,127 +1147,127 @@ JS::Result BinASTParser::parseSumStatement( template JS::Result BinASTParser::parseSumVariableDeclarationOrExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { ParseNode* result; switch (kind) { - case BinASTKind::ArrayExpression: + case BinKind::ArrayExpression: MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields)); break; - case BinASTKind::AssignmentExpression: + case BinKind::AssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields)); break; - case BinASTKind::AwaitExpression: + case BinKind::AwaitExpression: MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields)); break; - case BinASTKind::BinaryExpression: + case BinKind::BinaryExpression: MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields)); break; - case BinASTKind::CallExpression: + case BinKind::CallExpression: MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields)); break; - case BinASTKind::ClassExpression: + case BinKind::ClassExpression: MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields)); break; - case BinASTKind::CompoundAssignmentExpression: + case BinKind::CompoundAssignmentExpression: MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression( start, kind, fields)); break; - case BinASTKind::ComputedMemberExpression: + case BinKind::ComputedMemberExpression: MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields)); break; - case BinASTKind::ConditionalExpression: + case BinKind::ConditionalExpression: MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithExpression: + case BinKind::EagerArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::EagerArrowExpressionWithFunctionBody: + case BinKind::EagerArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::EagerFunctionExpression: + case BinKind::EagerFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields)); break; - case BinASTKind::IdentifierExpression: + case BinKind::IdentifierExpression: MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithExpression: + case BinKind::LazyArrowExpressionWithExpression: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithExpression( start, kind, fields)); break; - case BinASTKind::LazyArrowExpressionWithFunctionBody: + case BinKind::LazyArrowExpressionWithFunctionBody: MOZ_TRY_VAR(result, parseInterfaceLazyArrowExpressionWithFunctionBody( start, kind, fields)); break; - case BinASTKind::LazyFunctionExpression: + case BinKind::LazyFunctionExpression: MOZ_TRY_VAR(result, parseInterfaceLazyFunctionExpression(start, kind, fields)); break; - case BinASTKind::LiteralBooleanExpression: + case BinKind::LiteralBooleanExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields)); break; - case BinASTKind::LiteralInfinityExpression: + case BinKind::LiteralInfinityExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields)); break; - case BinASTKind::LiteralNullExpression: + case BinKind::LiteralNullExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields)); break; - case BinASTKind::LiteralNumericExpression: + case BinKind::LiteralNumericExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields)); break; - case BinASTKind::LiteralRegExpExpression: + case BinKind::LiteralRegExpExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields)); break; - case BinASTKind::LiteralStringExpression: + case BinKind::LiteralStringExpression: MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields)); break; - case BinASTKind::NewExpression: + case BinKind::NewExpression: MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields)); break; - case BinASTKind::NewTargetExpression: + case BinKind::NewTargetExpression: MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields)); break; - case BinASTKind::ObjectExpression: + case BinKind::ObjectExpression: MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields)); break; - case BinASTKind::StaticMemberExpression: + case BinKind::StaticMemberExpression: MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields)); break; - case BinASTKind::TemplateExpression: + case BinKind::TemplateExpression: MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields)); break; - case BinASTKind::ThisExpression: + case BinKind::ThisExpression: MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields)); break; - case BinASTKind::UnaryExpression: + case BinKind::UnaryExpression: MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields)); break; - case BinASTKind::UpdateExpression: + case BinKind::UpdateExpression: MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields)); break; - case BinASTKind::VariableDeclaration: + case BinKind::VariableDeclaration: MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields)); break; - case BinASTKind::YieldExpression: + case BinKind::YieldExpression: MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields)); break; - case BinASTKind::YieldStarExpression: + case BinKind::YieldStarExpression: MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields)); break; @@ -1282,7 +1282,7 @@ BinASTParser::parseSumVariableDeclarationOrExpression( // delegated to another parser. template JS::Result BinASTParser::parseInterfaceArrayAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(ArrayAssignmentTarget)"); @@ -1290,19 +1290,19 @@ JS::Result BinASTParser::parseInterfaceArrayAssignmentTarget( template JS::Result BinASTParser::parseInterfaceArrayBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (ArrayBinding)"); } template JS::Result BinASTParser::parseInterfaceArrayExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ArrayExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ArrayExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Elements}; + const BinField expected_fields[1] = {BinField::Elements}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -1323,12 +1323,12 @@ JS::Result BinASTParser::parseInterfaceArrayExpression( */ template JS::Result BinASTParser::parseAssertedBlockScope() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedBlockScope) { + if (kind != BinKind::AssertedBlockScope) { return raiseInvalidKind("AssertedBlockScope", kind); } const auto start = tokenizer_->offset(); @@ -1341,13 +1341,13 @@ JS::Result BinASTParser::parseAssertedBlockScope() { template JS::Result BinASTParser::parseInterfaceAssertedBlockScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssertedBlockScope); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssertedBlockScope); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::DeclaredNames, - BinASTField::HasDirectEval}; + const BinField expected_fields[2] = {BinField::DeclaredNames, + BinField::HasDirectEval}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto scopeKind = AssertedScopeKind::Block; @@ -1377,12 +1377,12 @@ JS::Result BinASTParser::parseInterfaceAssertedBlockScope( template JS::Result BinASTParser::parseAssertedBoundName( AssertedScopeKind scopeKind) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedBoundName) { + if (kind != BinKind::AssertedBoundName) { return raiseInvalidKind("AssertedBoundName", kind); } const auto start = tokenizer_->offset(); @@ -1395,14 +1395,13 @@ JS::Result BinASTParser::parseAssertedBoundName( template JS::Result BinASTParser::parseInterfaceAssertedBoundName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind) { - MOZ_ASSERT(kind == BinASTKind::AssertedBoundName); + MOZ_ASSERT(kind == BinKind::AssertedBoundName); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Name, - BinASTField::IsCaptured}; + const BinField expected_fields[2] = {BinField::Name, BinField::IsCaptured}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const bool allowDuplicateName = false; @@ -1428,12 +1427,12 @@ JS::Result BinASTParser::parseInterfaceAssertedBoundName( */ template JS::Result BinASTParser::parseAssertedBoundNamesScope() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedBoundNamesScope) { + if (kind != BinKind::AssertedBoundNamesScope) { return raiseInvalidKind("AssertedBoundNamesScope", kind); } const auto start = tokenizer_->offset(); @@ -1446,13 +1445,13 @@ JS::Result BinASTParser::parseAssertedBoundNamesScope() { template JS::Result BinASTParser::parseInterfaceAssertedBoundNamesScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssertedBoundNamesScope); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssertedBoundNamesScope); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::BoundNames, - BinASTField::HasDirectEval}; + const BinField expected_fields[2] = {BinField::BoundNames, + BinField::HasDirectEval}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto scopeKind = AssertedScopeKind::Catch; @@ -1483,12 +1482,12 @@ JS::Result BinASTParser::parseInterfaceAssertedBoundNamesScope( template JS::Result BinASTParser::parseAssertedDeclaredName( AssertedScopeKind scopeKind) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedDeclaredName) { + if (kind != BinKind::AssertedDeclaredName) { return raiseInvalidKind("AssertedDeclaredName", kind); } const auto start = tokenizer_->offset(); @@ -1501,14 +1500,14 @@ JS::Result BinASTParser::parseAssertedDeclaredName( template JS::Result BinASTParser::parseInterfaceAssertedDeclaredName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind) { - MOZ_ASSERT(kind == BinASTKind::AssertedDeclaredName); + MOZ_ASSERT(kind == BinKind::AssertedDeclaredName); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = {BinASTField::Name, BinASTField::Kind, - BinASTField::IsCaptured}; + const BinField expected_fields[3] = {BinField::Name, BinField::Kind, + BinField::IsCaptured}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const bool allowDuplicateName = false; @@ -1543,12 +1542,12 @@ JS::Result BinASTParser::parseInterfaceAssertedDeclaredName( template JS::Result BinASTParser::parseAssertedParameterScope( MutableHandle> positionalParams) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedParameterScope) { + if (kind != BinKind::AssertedParameterScope) { return raiseInvalidKind("AssertedParameterScope", kind); } const auto start = tokenizer_->offset(); @@ -1561,15 +1560,15 @@ JS::Result BinASTParser::parseAssertedParameterScope( template JS::Result BinASTParser::parseInterfaceAssertedParameterScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, MutableHandle> positionalParams) { - MOZ_ASSERT(kind == BinASTKind::AssertedParameterScope); + MOZ_ASSERT(kind == BinKind::AssertedParameterScope); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = {BinASTField::ParamNames, - BinASTField::HasDirectEval, - BinASTField::IsSimpleParameterList}; + const BinField expected_fields[3] = {BinField::ParamNames, + BinField::HasDirectEval, + BinField::IsSimpleParameterList}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto scopeKind = AssertedScopeKind::Parameter; @@ -1595,15 +1594,15 @@ JS::Result BinASTParser::parseInterfaceAssertedParameterScope( template JS::Result BinASTParser::parseInterfaceAssertedPositionalParameterName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind, MutableHandle> positionalParams) { - MOZ_ASSERT(kind == BinASTKind::AssertedPositionalParameterName); + MOZ_ASSERT(kind == BinKind::AssertedPositionalParameterName); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = {BinASTField::Index, BinASTField::Name, - BinASTField::IsCaptured}; + const BinField expected_fields[3] = {BinField::Index, BinField::Name, + BinField::IsCaptured}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) bool allowDuplicateName = !pc_->sc()->strict(); @@ -1652,12 +1651,12 @@ JS::Result BinASTParser::parseInterfaceAssertedPositionalParameterName( */ template JS::Result BinASTParser::parseAssertedScriptGlobalScope() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedScriptGlobalScope) { + if (kind != BinKind::AssertedScriptGlobalScope) { return raiseInvalidKind("AssertedScriptGlobalScope", kind); } const auto start = tokenizer_->offset(); @@ -1670,13 +1669,13 @@ JS::Result BinASTParser::parseAssertedScriptGlobalScope() { template JS::Result BinASTParser::parseInterfaceAssertedScriptGlobalScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssertedScriptGlobalScope); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssertedScriptGlobalScope); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::DeclaredNames, - BinASTField::HasDirectEval}; + const BinField expected_fields[2] = {BinField::DeclaredNames, + BinField::HasDirectEval}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto scopeKind = AssertedScopeKind::Global; @@ -1705,12 +1704,12 @@ JS::Result BinASTParser::parseInterfaceAssertedScriptGlobalScope( */ template JS::Result BinASTParser::parseAssertedVarScope() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::AssertedVarScope) { + if (kind != BinKind::AssertedVarScope) { return raiseInvalidKind("AssertedVarScope", kind); } const auto start = tokenizer_->offset(); @@ -1723,13 +1722,13 @@ JS::Result BinASTParser::parseAssertedVarScope() { template JS::Result BinASTParser::parseInterfaceAssertedVarScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssertedVarScope); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssertedVarScope); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::DeclaredNames, - BinASTField::HasDirectEval}; + const BinField expected_fields[2] = {BinField::DeclaredNames, + BinField::HasDirectEval}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto scopeKind = AssertedScopeKind::Var; @@ -1752,13 +1751,12 @@ JS::Result BinASTParser::parseInterfaceAssertedVarScope( template JS::Result BinASTParser::parseInterfaceAssignmentExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssignmentExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssignmentExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Binding, - BinASTField::Expression}; + const BinField expected_fields[2] = {BinField::Binding, BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -1774,12 +1772,12 @@ JS::Result BinASTParser::parseInterfaceAssignmentExpression( template JS::Result BinASTParser::parseInterfaceAssignmentTargetIdentifier( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::AssignmentTargetIdentifier); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::AssignmentTargetIdentifier); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Name}; + const BinField expected_fields[1] = {BinField::Name}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -1795,20 +1793,20 @@ BinASTParser::parseInterfaceAssignmentTargetIdentifier( template JS::Result BinASTParser::parseInterfaceAwaitExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (AwaitExpression)"); } template JS::Result BinASTParser::parseInterfaceBinaryExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::BinaryExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::BinaryExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Operator, BinASTField::Left, BinASTField::Right}; + const BinField expected_fields[3] = {BinField::Operator, BinField::Left, + BinField::Right}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -1920,12 +1918,12 @@ JS::Result BinASTParser::parseInterfaceBinaryExpression( */ template JS::Result BinASTParser::parseBindingIdentifier() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::BindingIdentifier) { + if (kind != BinKind::BindingIdentifier) { return raiseInvalidKind("BindingIdentifier", kind); } const auto start = tokenizer_->offset(); @@ -1938,12 +1936,12 @@ JS::Result BinASTParser::parseBindingIdentifier() { template JS::Result BinASTParser::parseInterfaceBindingIdentifier( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::BindingIdentifier); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::BindingIdentifier); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Name}; + const BinField expected_fields[1] = {BinField::Name}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -1957,7 +1955,7 @@ JS::Result BinASTParser::parseInterfaceBindingIdentifier( template JS::Result BinASTParser::parseInterfaceBindingWithInitializer( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(BindingWithInitializer)"); @@ -1971,12 +1969,12 @@ JS::Result BinASTParser::parseInterfaceBindingWithInitializer( */ template JS::Result BinASTParser::parseBlock() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::Block) { + if (kind != BinKind::Block) { return raiseInvalidKind("Block", kind); } const auto start = tokenizer_->offset(); @@ -1988,13 +1986,12 @@ JS::Result BinASTParser::parseBlock() { template JS::Result BinASTParser::parseInterfaceBlock( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::Block); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::Block); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Scope, - BinASTField::Statements}; + const BinField expected_fields[2] = {BinField::Scope, BinField::Statements}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::Block); @@ -2013,12 +2010,12 @@ JS::Result BinASTParser::parseInterfaceBlock( template JS::Result BinASTParser::parseInterfaceBreakStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::BreakStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::BreakStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Label}; + const BinField expected_fields[1] = {BinField::Label}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) RootedAtom label(cx_); @@ -2051,13 +2048,12 @@ JS::Result BinASTParser::parseInterfaceBreakStatement( template JS::Result BinASTParser::parseInterfaceCallExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::CallExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::CallExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Callee, - BinASTField::Arguments}; + const BinField expected_fields[2] = {BinField::Callee, BinField::Arguments}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2106,12 +2102,12 @@ JS::Result BinASTParser::parseInterfaceCallExpression( */ template JS::Result BinASTParser::parseCatchClause() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::CatchClause) { + if (kind != BinKind::CatchClause) { return raiseInvalidKind("CatchClause", kind); } const auto start = tokenizer_->offset(); @@ -2123,13 +2119,13 @@ JS::Result BinASTParser::parseCatchClause() { template JS::Result BinASTParser::parseInterfaceCatchClause( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::CatchClause); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::CatchClause); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::BindingScope, BinASTField::Binding, BinASTField::Body}; + const BinField expected_fields[3] = {BinField::BindingScope, + BinField::Binding, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::Catch); @@ -2154,14 +2150,14 @@ JS::Result BinASTParser::parseInterfaceCatchClause( template JS::Result BinASTParser::parseInterfaceClassDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (ClassDeclaration)"); } template JS::Result BinASTParser::parseInterfaceClassExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (ClassExpression)"); } @@ -2169,13 +2165,13 @@ JS::Result BinASTParser::parseInterfaceClassExpression( template JS::Result BinASTParser::parseInterfaceCompoundAssignmentExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::CompoundAssignmentExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::CompoundAssignmentExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Operator, BinASTField::Binding, BinASTField::Expression}; + const BinField expected_fields[3] = {BinField::Operator, BinField::Binding, + BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2231,13 +2227,12 @@ BinASTParser::parseInterfaceCompoundAssignmentExpression( template JS::Result BinASTParser::parseInterfaceComputedMemberAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ComputedMemberAssignmentTarget); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ComputedMemberAssignmentTarget); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Object, - BinASTField::Expression}; + const BinField expected_fields[2] = {BinField::Object, BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2253,13 +2248,12 @@ BinASTParser::parseInterfaceComputedMemberAssignmentTarget( template JS::Result BinASTParser::parseInterfaceComputedMemberExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ComputedMemberExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ComputedMemberExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Object, - BinASTField::Expression}; + const BinField expected_fields[2] = {BinField::Object, BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2274,7 +2268,7 @@ BinASTParser::parseInterfaceComputedMemberExpression( template JS::Result BinASTParser::parseInterfaceComputedPropertyName( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(ComputedPropertyName)"); @@ -2282,13 +2276,13 @@ JS::Result BinASTParser::parseInterfaceComputedPropertyName( template JS::Result BinASTParser::parseInterfaceConditionalExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ConditionalExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ConditionalExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Test, BinASTField::Consequent, BinASTField::Alternate}; + const BinField expected_fields[3] = {BinField::Test, BinField::Consequent, + BinField::Alternate}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2304,12 +2298,12 @@ JS::Result BinASTParser::parseInterfaceConditionalExpression( template JS::Result BinASTParser::parseInterfaceContinueStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ContinueStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ContinueStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Label}; + const BinField expected_fields[1] = {BinField::Label}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) RootedAtom label(cx_); @@ -2342,13 +2336,12 @@ JS::Result BinASTParser::parseInterfaceContinueStatement( template JS::Result BinASTParser::parseInterfaceDataProperty( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::DataProperty); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::DataProperty); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Name, - BinASTField::Expression}; + const BinField expected_fields[2] = {BinField::Name, BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2374,7 +2367,7 @@ JS::Result BinASTParser::parseInterfaceDataProperty( template JS::Result BinASTParser::parseInterfaceDebuggerStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (DebuggerStatement)"); } @@ -2386,12 +2379,12 @@ JS::Result BinASTParser::parseInterfaceDebuggerStatement( */ template JS::Result BinASTParser::parseDirective() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::Directive) { + if (kind != BinKind::Directive) { return raiseInvalidKind("Directive", kind); } const auto start = tokenizer_->offset(); @@ -2403,12 +2396,12 @@ JS::Result BinASTParser::parseDirective() { template JS::Result BinASTParser::parseInterfaceDirective( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::Directive); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::Directive); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::RawValue}; + const BinField expected_fields[1] = {BinField::RawValue}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2422,12 +2415,12 @@ JS::Result BinASTParser::parseInterfaceDirective( template JS::Result BinASTParser::parseInterfaceDoWhileStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::DoWhileStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::DoWhileStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Test, BinASTField::Body}; + const BinField expected_fields[2] = {BinField::Test, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::DoLoop); @@ -2444,7 +2437,7 @@ JS::Result BinASTParser::parseInterfaceDoWhileStatement( template JS::Result BinASTParser::parseInterfaceEagerArrowExpressionWithExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(EagerArrowExpressionWithExpression)"); @@ -2453,7 +2446,7 @@ BinASTParser::parseInterfaceEagerArrowExpressionWithExpression( template JS::Result BinASTParser::parseInterfaceEagerArrowExpressionWithFunctionBody( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(EagerArrowExpressionWithFunctionBody)"); @@ -2462,14 +2455,14 @@ BinASTParser::parseInterfaceEagerArrowExpressionWithFunctionBody( template JS::Result BinASTParser::parseInterfaceEagerFunctionDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EagerFunctionDeclaration); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EagerFunctionDeclaration); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[6] = { - BinASTField::IsAsync, BinASTField::IsGenerator, BinASTField::Name, - BinASTField::Length, BinASTField::Directives, BinASTField::Contents}; + const BinField expected_fields[6] = { + BinField::IsAsync, BinField::IsGenerator, BinField::Name, + BinField::Length, BinField::Directives, BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Statement; @@ -2504,7 +2497,7 @@ BinASTParser::parseInterfaceEagerFunctionDeclaration( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -2525,14 +2518,14 @@ BinASTParser::parseInterfaceEagerFunctionDeclaration( template JS::Result BinASTParser::parseInterfaceEagerFunctionExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EagerFunctionExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EagerFunctionExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[6] = { - BinASTField::IsAsync, BinASTField::IsGenerator, BinASTField::Name, - BinASTField::Length, BinASTField::Directives, BinASTField::Contents}; + const BinField expected_fields[6] = { + BinField::IsAsync, BinField::IsGenerator, BinField::Name, + BinField::Length, BinField::Directives, BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Expression; @@ -2567,7 +2560,7 @@ JS::Result BinASTParser::parseInterfaceEagerFunctionExpression( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -2588,13 +2581,13 @@ JS::Result BinASTParser::parseInterfaceEagerFunctionExpression( template JS::Result BinASTParser::parseInterfaceEagerGetter( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EagerGetter); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EagerGetter); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Name, BinASTField::Directives, BinASTField::Contents}; + const BinField expected_fields[3] = {BinField::Name, BinField::Directives, + BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Setter; @@ -2622,7 +2615,7 @@ JS::Result BinASTParser::parseInterfaceEagerGetter( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -2645,14 +2638,14 @@ JS::Result BinASTParser::parseInterfaceEagerGetter( template JS::Result BinASTParser::parseInterfaceEagerMethod( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EagerMethod); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EagerMethod); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[6] = { - BinASTField::IsAsync, BinASTField::IsGenerator, BinASTField::Name, - BinASTField::Length, BinASTField::Directives, BinASTField::Contents}; + const BinField expected_fields[6] = { + BinField::IsAsync, BinField::IsGenerator, BinField::Name, + BinField::Length, BinField::Directives, BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Method; @@ -2688,7 +2681,7 @@ JS::Result BinASTParser::parseInterfaceEagerMethod( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -2711,14 +2704,14 @@ JS::Result BinASTParser::parseInterfaceEagerMethod( template JS::Result BinASTParser::parseInterfaceEagerSetter( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EagerSetter); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EagerSetter); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[4] = { - BinASTField::Name, BinASTField::Length, BinASTField::Directives, - BinASTField::Contents}; + const BinField expected_fields[4] = {BinField::Name, BinField::Length, + BinField::Directives, + BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Setter; @@ -2747,7 +2740,7 @@ JS::Result BinASTParser::parseInterfaceEagerSetter( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -2770,8 +2763,8 @@ JS::Result BinASTParser::parseInterfaceEagerSetter( template JS::Result BinASTParser::parseInterfaceEmptyStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::EmptyStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::EmptyStatement); BINJS_TRY(CheckRecursionLimit(cx_)); MOZ_TRY(tokenizer_->checkFields0(kind, fields)); @@ -2781,12 +2774,12 @@ JS::Result BinASTParser::parseInterfaceEmptyStatement( template JS::Result BinASTParser::parseInterfaceExpressionStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ExpressionStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ExpressionStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Expression}; + const BinField expected_fields[1] = {BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2799,13 +2792,12 @@ JS::Result BinASTParser::parseInterfaceExpressionStatement( template JS::Result BinASTParser::parseInterfaceForInOfBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ForInOfBinding); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ForInOfBinding); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Kind, - BinASTField::Binding}; + const BinField expected_fields[2] = {BinField::Kind, BinField::Binding}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) AutoVariableDeclarationKind kindGuard(this); @@ -2836,13 +2828,13 @@ JS::Result BinASTParser::parseInterfaceForInOfBinding( template JS::Result BinASTParser::parseInterfaceForInStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ForInStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ForInStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = {BinASTField::Left, BinASTField::Right, - BinASTField::Body}; + const BinField expected_fields[3] = {BinField::Left, BinField::Right, + BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::ForInLoop); @@ -2875,21 +2867,20 @@ JS::Result BinASTParser::parseInterfaceForInStatement( template JS::Result BinASTParser::parseInterfaceForOfStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (ForOfStatement)"); } template JS::Result BinASTParser::parseInterfaceForStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ForStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ForStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[4] = {BinASTField::Init, BinASTField::Test, - BinASTField::Update, - BinASTField::Body}; + const BinField expected_fields[4] = {BinField::Init, BinField::Test, + BinField::Update, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::ForLoop); @@ -2929,12 +2920,12 @@ JS::Result BinASTParser::parseInterfaceForStatement( */ template JS::Result BinASTParser::parseFormalParameters() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::FormalParameters) { + if (kind != BinKind::FormalParameters) { return raiseInvalidKind("FormalParameters", kind); } const auto start = tokenizer_->offset(); @@ -2947,13 +2938,12 @@ JS::Result BinASTParser::parseFormalParameters() { template JS::Result BinASTParser::parseInterfaceFormalParameters( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::FormalParameters); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::FormalParameters); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Items, - BinASTField::Rest}; + const BinField expected_fields[2] = {BinField::Items, BinField::Rest}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -2982,12 +2972,12 @@ JS::Result BinASTParser::parseInterfaceFormalParameters( template JS::Result BinASTParser::parseFunctionExpressionContents( uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::FunctionExpressionContents) { + if (kind != BinKind::FunctionExpressionContents) { return raiseInvalidKind("FunctionExpressionContents", kind); } const auto start = tokenizer_->offset(); @@ -3001,18 +2991,18 @@ JS::Result BinASTParser::parseFunctionExpressionContents( template JS::Result BinASTParser::parseInterfaceFunctionExpressionContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - MOZ_ASSERT(kind == BinASTKind::FunctionExpressionContents); + MOZ_ASSERT(kind == BinKind::FunctionExpressionContents); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[6] = {BinASTField::IsFunctionNameCaptured, - BinASTField::IsThisCaptured, - BinASTField::ParameterScope, - BinASTField::Params, - BinASTField::BodyScope, - BinASTField::Body}; + const BinField expected_fields[6] = {BinField::IsFunctionNameCaptured, + BinField::IsThisCaptured, + BinField::ParameterScope, + BinField::Params, + BinField::BodyScope, + BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3055,12 +3045,12 @@ JS::Result BinASTParser::parseInterfaceFunctionExpressionContents( template JS::Result BinASTParser::parseFunctionOrMethodContents( uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::FunctionOrMethodContents) { + if (kind != BinKind::FunctionOrMethodContents) { return raiseInvalidKind("FunctionOrMethodContents", kind); } const auto start = tokenizer_->offset(); @@ -3074,15 +3064,15 @@ JS::Result BinASTParser::parseFunctionOrMethodContents( template JS::Result BinASTParser::parseInterfaceFunctionOrMethodContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - MOZ_ASSERT(kind == BinASTKind::FunctionOrMethodContents); + MOZ_ASSERT(kind == BinKind::FunctionOrMethodContents); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[5] = { - BinASTField::IsThisCaptured, BinASTField::ParameterScope, - BinASTField::Params, BinASTField::BodyScope, BinASTField::Body}; + const BinField expected_fields[5] = { + BinField::IsThisCaptured, BinField::ParameterScope, BinField::Params, + BinField::BodyScope, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3116,12 +3106,12 @@ template JS::Result BinASTParser::parseGetterContents(uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::GetterContents) { + if (kind != BinKind::GetterContents) { return raiseInvalidKind("GetterContents", kind); } const auto start = tokenizer_->offset(); @@ -3135,14 +3125,14 @@ JS::Result BinASTParser::parseGetterContents(uint32_t funLength, template JS::Result BinASTParser::parseInterfaceGetterContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - MOZ_ASSERT(kind == BinASTKind::GetterContents); + MOZ_ASSERT(kind == BinKind::GetterContents); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::IsThisCaptured, BinASTField::BodyScope, BinASTField::Body}; + const BinField expected_fields[3] = {BinField::IsThisCaptured, + BinField::BodyScope, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3167,12 +3157,12 @@ JS::Result BinASTParser::parseInterfaceGetterContents( */ template JS::Result BinASTParser::parseIdentifierExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::IdentifierExpression) { + if (kind != BinKind::IdentifierExpression) { return raiseInvalidKind("IdentifierExpression", kind); } const auto start = tokenizer_->offset(); @@ -3185,12 +3175,12 @@ JS::Result BinASTParser::parseIdentifierExpression() { template JS::Result BinASTParser::parseInterfaceIdentifierExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::IdentifierExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::IdentifierExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Name}; + const BinField expected_fields[1] = {BinField::Name}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3206,13 +3196,13 @@ JS::Result BinASTParser::parseInterfaceIdentifierExpression( template JS::Result BinASTParser::parseInterfaceIfStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::IfStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::IfStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Test, BinASTField::Consequent, BinASTField::Alternate}; + const BinField expected_fields[3] = {BinField::Test, BinField::Consequent, + BinField::Alternate}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3229,13 +3219,12 @@ JS::Result BinASTParser::parseInterfaceIfStatement( template JS::Result BinASTParser::parseInterfaceLabelledStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LabelledStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LabelledStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Label, - BinASTField::Body}; + const BinField expected_fields[2] = {BinField::Label, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3255,7 +3244,7 @@ JS::Result BinASTParser::parseInterfaceLabelledStatement( template JS::Result BinASTParser::parseInterfaceLazyArrowExpressionWithExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(LazyArrowExpressionWithExpression)"); @@ -3264,7 +3253,7 @@ BinASTParser::parseInterfaceLazyArrowExpressionWithExpression( template JS::Result BinASTParser::parseInterfaceLazyArrowExpressionWithFunctionBody( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(LazyArrowExpressionWithFunctionBody)"); @@ -3272,15 +3261,15 @@ BinASTParser::parseInterfaceLazyArrowExpressionWithFunctionBody( template JS::Result BinASTParser::parseInterfaceLazyFunctionDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LazyFunctionDeclaration); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LazyFunctionDeclaration); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[7] = { - BinASTField::IsAsync, BinASTField::IsGenerator, BinASTField::Name, - BinASTField::Length, BinASTField::Directives, BinASTField::ContentsSkip, - BinASTField::Contents}; + const BinField expected_fields[7] = { + BinField::IsAsync, BinField::IsGenerator, BinField::Name, + BinField::Length, BinField::Directives, BinField::ContentsSkip, + BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Statement; @@ -3337,15 +3326,15 @@ JS::Result BinASTParser::parseInterfaceLazyFunctionDeclaration( template JS::Result BinASTParser::parseInterfaceLazyFunctionExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LazyFunctionExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LazyFunctionExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[7] = { - BinASTField::IsAsync, BinASTField::IsGenerator, BinASTField::Name, - BinASTField::Length, BinASTField::Directives, BinASTField::ContentsSkip, - BinASTField::Contents}; + const BinField expected_fields[7] = { + BinField::IsAsync, BinField::IsGenerator, BinField::Name, + BinField::Length, BinField::Directives, BinField::ContentsSkip, + BinField::Contents}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) const auto syntax = FunctionSyntaxKind::Expression; @@ -3402,21 +3391,21 @@ JS::Result BinASTParser::parseInterfaceLazyFunctionExpression( template JS::Result BinASTParser::parseInterfaceLazyGetter( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (LazyGetter)"); } template JS::Result BinASTParser::parseInterfaceLazyMethod( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (LazyMethod)"); } template JS::Result BinASTParser::parseInterfaceLazySetter( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (LazySetter)"); } @@ -3424,12 +3413,12 @@ JS::Result BinASTParser::parseInterfaceLazySetter( template JS::Result BinASTParser::parseInterfaceLiteralBooleanExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralBooleanExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Value}; + const BinField expected_fields[1] = {BinField::Value}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3443,7 +3432,7 @@ BinASTParser::parseInterfaceLiteralBooleanExpression( template JS::Result BinASTParser::parseInterfaceLiteralInfinityExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(LiteralInfinityExpression)"); @@ -3451,8 +3440,8 @@ BinASTParser::parseInterfaceLiteralInfinityExpression( template JS::Result BinASTParser::parseInterfaceLiteralNullExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralNullExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralNullExpression); BINJS_TRY(CheckRecursionLimit(cx_)); MOZ_TRY(tokenizer_->checkFields0(kind, fields)); @@ -3463,12 +3452,12 @@ JS::Result BinASTParser::parseInterfaceLiteralNullExpression( template JS::Result BinASTParser::parseInterfaceLiteralNumericExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralNumericExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralNumericExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Value}; + const BinField expected_fields[1] = {BinField::Value}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3481,12 +3470,12 @@ BinASTParser::parseInterfaceLiteralNumericExpression( template JS::Result BinASTParser::parseInterfaceLiteralPropertyName( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralPropertyName); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralPropertyName); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Value}; + const BinField expected_fields[1] = {BinField::Value}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3508,13 +3497,12 @@ JS::Result BinASTParser::parseInterfaceLiteralPropertyName( template JS::Result BinASTParser::parseInterfaceLiteralRegExpExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralRegExpExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralRegExpExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Pattern, - BinASTField::Flags}; + const BinField expected_fields[2] = {BinField::Pattern, BinField::Flags}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3551,12 +3539,12 @@ JS::Result BinASTParser::parseInterfaceLiteralRegExpExpression( template JS::Result BinASTParser::parseInterfaceLiteralStringExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::LiteralStringExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::LiteralStringExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Value}; + const BinField expected_fields[1] = {BinField::Value}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3570,20 +3558,19 @@ JS::Result BinASTParser::parseInterfaceLiteralStringExpression( template JS::Result BinASTParser::parseInterfaceModule( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (Module)"); } template JS::Result BinASTParser::parseInterfaceNewExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::NewExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::NewExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Callee, - BinASTField::Arguments}; + const BinField expected_fields[2] = {BinField::Callee, BinField::Arguments}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3598,7 +3585,7 @@ JS::Result BinASTParser::parseInterfaceNewExpression( template JS::Result BinASTParser::parseInterfaceNewTargetExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(NewTargetExpression)"); @@ -3606,7 +3593,7 @@ JS::Result BinASTParser::parseInterfaceNewTargetExpression( template JS::Result BinASTParser::parseInterfaceObjectAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(ObjectAssignmentTarget)"); @@ -3614,19 +3601,19 @@ JS::Result BinASTParser::parseInterfaceObjectAssignmentTarget( template JS::Result BinASTParser::parseInterfaceObjectBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (ObjectBinding)"); } template JS::Result BinASTParser::parseInterfaceObjectExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ObjectExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ObjectExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Properties}; + const BinField expected_fields[1] = {BinField::Properties}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3638,12 +3625,12 @@ JS::Result BinASTParser::parseInterfaceObjectExpression( template JS::Result BinASTParser::parseInterfaceReturnStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ReturnStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ReturnStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Expression}; + const BinField expected_fields[1] = {BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) if (!pc_->isFunctionBox()) { @@ -3662,13 +3649,13 @@ JS::Result BinASTParser::parseInterfaceReturnStatement( template JS::Result BinASTParser::parseInterfaceScript( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::Script); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::Script); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Scope, BinASTField::Directives, BinASTField::Statements}; + const BinField expected_fields[3] = {BinField::Scope, BinField::Directives, + BinField::Statements}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3697,12 +3684,12 @@ template JS::Result BinASTParser::parseSetterContents(uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::SetterContents) { + if (kind != BinKind::SetterContents) { return raiseInvalidKind("SetterContents", kind); } const auto start = tokenizer_->offset(); @@ -3716,15 +3703,15 @@ JS::Result BinASTParser::parseSetterContents(uint32_t funLength, template JS::Result BinASTParser::parseInterfaceSetterContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut) { - MOZ_ASSERT(kind == BinASTKind::SetterContents); + MOZ_ASSERT(kind == BinKind::SetterContents); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[5] = { - BinASTField::IsThisCaptured, BinASTField::ParameterScope, - BinASTField::Param, BinASTField::BodyScope, BinASTField::Body}; + const BinField expected_fields[5] = { + BinField::IsThisCaptured, BinField::ParameterScope, BinField::Param, + BinField::BodyScope, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3750,12 +3737,12 @@ JS::Result BinASTParser::parseInterfaceSetterContents( template JS::Result BinASTParser::parseInterfaceShorthandProperty( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ShorthandProperty); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ShorthandProperty); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Name}; + const BinField expected_fields[1] = {BinField::Name}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3774,7 +3761,7 @@ JS::Result BinASTParser::parseInterfaceShorthandProperty( template JS::Result BinASTParser::parseInterfaceSpreadElement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (SpreadElement)"); } @@ -3782,13 +3769,12 @@ JS::Result BinASTParser::parseInterfaceSpreadElement( template JS::Result BinASTParser::parseInterfaceStaticMemberAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::StaticMemberAssignmentTarget); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::StaticMemberAssignmentTarget); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Object, - BinASTField::Property}; + const BinField expected_fields[2] = {BinField::Object, BinField::Property}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) size_t nameStart; @@ -3808,13 +3794,12 @@ BinASTParser::parseInterfaceStaticMemberAssignmentTarget( template JS::Result BinASTParser::parseInterfaceStaticMemberExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::StaticMemberExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::StaticMemberExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Object, - BinASTField::Property}; + const BinField expected_fields[2] = {BinField::Object, BinField::Property}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) size_t nameStart; @@ -3834,7 +3819,7 @@ JS::Result BinASTParser::parseInterfaceStaticMemberExpression( template JS::Result BinASTParser::parseInterfaceSuper( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (Super)"); } @@ -3847,12 +3832,12 @@ JS::Result BinASTParser::parseInterfaceSuper( */ template JS::Result BinASTParser::parseSwitchCase() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::SwitchCase) { + if (kind != BinKind::SwitchCase) { return raiseInvalidKind("SwitchCase", kind); } const auto start = tokenizer_->offset(); @@ -3864,13 +3849,12 @@ JS::Result BinASTParser::parseSwitchCase() { template JS::Result BinASTParser::parseInterfaceSwitchCase( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::SwitchCase); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::SwitchCase); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Test, - BinASTField::Consequent}; + const BinField expected_fields[2] = {BinField::Test, BinField::Consequent}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3889,12 +3873,12 @@ JS::Result BinASTParser::parseInterfaceSwitchCase( */ template JS::Result BinASTParser::parseSwitchDefault() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::SwitchDefault) { + if (kind != BinKind::SwitchDefault) { return raiseInvalidKind("SwitchDefault", kind); } const auto start = tokenizer_->offset(); @@ -3906,12 +3890,12 @@ JS::Result BinASTParser::parseSwitchDefault() { template JS::Result BinASTParser::parseInterfaceSwitchDefault( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::SwitchDefault); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::SwitchDefault); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Consequent}; + const BinField expected_fields[1] = {BinField::Consequent}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3923,13 +3907,12 @@ JS::Result BinASTParser::parseInterfaceSwitchDefault( template JS::Result BinASTParser::parseInterfaceSwitchStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::SwitchStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::SwitchStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Discriminant, - BinASTField::Cases}; + const BinField expected_fields[2] = {BinField::Discriminant, BinField::Cases}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3946,14 +3929,14 @@ JS::Result BinASTParser::parseInterfaceSwitchStatement( template JS::Result BinASTParser::parseInterfaceSwitchStatementWithDefault( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::SwitchStatementWithDefault); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::SwitchStatementWithDefault); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[4] = { - BinASTField::Discriminant, BinASTField::PreDefaultCases, - BinASTField::DefaultCase, BinASTField::PostDefaultCases}; + const BinField expected_fields[4] = { + BinField::Discriminant, BinField::PreDefaultCases, BinField::DefaultCase, + BinField::PostDefaultCases}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -3982,7 +3965,7 @@ BinASTParser::parseInterfaceSwitchStatementWithDefault( template JS::Result BinASTParser::parseInterfaceTemplateExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(TemplateExpression)"); @@ -3990,8 +3973,8 @@ JS::Result BinASTParser::parseInterfaceTemplateExpression( template JS::Result BinASTParser::parseInterfaceThisExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ThisExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ThisExpression); BINJS_TRY(CheckRecursionLimit(cx_)); MOZ_TRY(tokenizer_->checkFields0(kind, fields)); @@ -4014,12 +3997,12 @@ JS::Result BinASTParser::parseInterfaceThisExpression( template JS::Result BinASTParser::parseInterfaceThrowStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::ThrowStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::ThrowStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[1] = {BinASTField::Expression}; + const BinField expected_fields[1] = {BinField::Expression}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -4032,13 +4015,12 @@ JS::Result BinASTParser::parseInterfaceThrowStatement( template JS::Result BinASTParser::parseInterfaceTryCatchStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::TryCatchStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::TryCatchStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Body, - BinASTField::CatchClause}; + const BinField expected_fields[2] = {BinField::Body, BinField::CatchClause}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseNode* body; @@ -4059,13 +4041,13 @@ JS::Result BinASTParser::parseInterfaceTryCatchStatement( template JS::Result BinASTParser::parseInterfaceTryFinallyStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::TryFinallyStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::TryFinallyStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::Body, BinASTField::CatchClause, BinASTField::Finalizer}; + const BinField expected_fields[3] = {BinField::Body, BinField::CatchClause, + BinField::Finalizer}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseNode* body; @@ -4092,13 +4074,12 @@ JS::Result BinASTParser::parseInterfaceTryFinallyStatement( template JS::Result BinASTParser::parseInterfaceUnaryExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::UnaryExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::UnaryExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Operator, - BinASTField::Operand}; + const BinField expected_fields[2] = {BinField::Operator, BinField::Operand}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -4157,13 +4138,13 @@ JS::Result BinASTParser::parseInterfaceUnaryExpression( template JS::Result BinASTParser::parseInterfaceUpdateExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::UpdateExpression); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::UpdateExpression); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[3] = { - BinASTField::IsPrefix, BinASTField::Operator, BinASTField::Operand}; + const BinField expected_fields[3] = {BinField::IsPrefix, BinField::Operator, + BinField::Operand}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -4190,13 +4171,12 @@ JS::Result BinASTParser::parseInterfaceUpdateExpression( template JS::Result BinASTParser::parseInterfaceVariableDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::VariableDeclaration); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::VariableDeclaration); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Kind, - BinASTField::Declarators}; + const BinField expected_fields[2] = {BinField::Kind, BinField::Declarators}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) AutoVariableDeclarationKind kindGuard(this); @@ -4234,12 +4214,12 @@ JS::Result BinASTParser::parseInterfaceVariableDeclaration( */ template JS::Result BinASTParser::parseVariableDeclarator() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::VariableDeclarator) { + if (kind != BinKind::VariableDeclarator) { return raiseInvalidKind("VariableDeclarator", kind); } const auto start = tokenizer_->offset(); @@ -4252,13 +4232,12 @@ JS::Result BinASTParser::parseVariableDeclarator() { template JS::Result BinASTParser::parseInterfaceVariableDeclarator( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::VariableDeclarator); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::VariableDeclarator); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Binding, - BinASTField::Init}; + const BinField expected_fields[2] = {BinField::Binding, BinField::Init}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -4282,7 +4261,7 @@ JS::Result BinASTParser::parseInterfaceVariableDeclarator( if (!init) { // Here, `init` is required. return raiseMissingField("VariableDeclarator (with non-trivial pattern)", - BinASTField::Init); + BinField::Init); } MOZ_CRASH( @@ -4296,12 +4275,12 @@ JS::Result BinASTParser::parseInterfaceVariableDeclarator( template JS::Result BinASTParser::parseInterfaceWhileStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::WhileStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::WhileStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Test, BinASTField::Body}; + const BinField expected_fields[2] = {BinField::Test, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) ParseContext::Statement stmt(pc_, StatementKind::WhileLoop); @@ -4316,13 +4295,12 @@ JS::Result BinASTParser::parseInterfaceWhileStatement( template JS::Result BinASTParser::parseInterfaceWithStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { - MOZ_ASSERT(kind == BinASTKind::WithStatement); + const size_t start, const BinKind kind, const BinFields& fields) { + MOZ_ASSERT(kind == BinKind::WithStatement); BINJS_TRY(CheckRecursionLimit(cx_)); #if defined(DEBUG) - const BinASTField expected_fields[2] = {BinASTField::Object, - BinASTField::Body}; + const BinField expected_fields[2] = {BinField::Object, BinField::Body}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG) @@ -4338,14 +4316,14 @@ JS::Result BinASTParser::parseInterfaceWithStatement( template JS::Result BinASTParser::parseInterfaceYieldExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release (YieldExpression)"); } template JS::Result BinASTParser::parseInterfaceYieldStarExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields) { + const size_t start, const BinKind kind, const BinFields& fields) { return raiseError( "FIXME: Not implemented yet in this preview release " "(YieldStarExpression)"); @@ -4365,11 +4343,11 @@ BinASTParser::parseAssertedDeclaredKind() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::AssertedDeclaredKindOrVariableDeclarationKindVar: + case BinVariant::AssertedDeclaredKindOrVariableDeclarationKindVar: return AssertedDeclaredKind::Var; - case BinASTVariant::AssertedDeclaredKindNonConstLexical: + case BinVariant::AssertedDeclaredKindNonConstLexical: return AssertedDeclaredKind::NonConstLexical; - case BinASTVariant::AssertedDeclaredKindConstLexical: + case BinVariant::AssertedDeclaredKindConstLexical: return AssertedDeclaredKind::ConstLexical; default: return raiseInvalidVariant("AssertedDeclaredKind", variant); @@ -4411,55 +4389,55 @@ BinASTParser::parseBinaryOperator() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::BinaryOperatorComma: + case BinVariant::BinaryOperatorComma: return BinaryOperator::Comma; - case BinASTVariant::BinaryOperatorLogicalOr: + case BinVariant::BinaryOperatorLogicalOr: return BinaryOperator::LogicalOr; - case BinASTVariant::BinaryOperatorLogicalAnd: + case BinVariant::BinaryOperatorLogicalAnd: return BinaryOperator::LogicalAnd; - case BinASTVariant::BinaryOperatorBitOr: + case BinVariant::BinaryOperatorBitOr: return BinaryOperator::BitOr; - case BinASTVariant::BinaryOperatorBitXor: + case BinVariant::BinaryOperatorBitXor: return BinaryOperator::BitXor; - case BinASTVariant::BinaryOperatorBitAnd: + case BinVariant::BinaryOperatorBitAnd: return BinaryOperator::BitAnd; - case BinASTVariant::BinaryOperatorEq: + case BinVariant::BinaryOperatorEq: return BinaryOperator::Eq; - case BinASTVariant::BinaryOperatorNeq: + case BinVariant::BinaryOperatorNeq: return BinaryOperator::Neq; - case BinASTVariant::BinaryOperatorStrictEq: + case BinVariant::BinaryOperatorStrictEq: return BinaryOperator::StrictEq; - case BinASTVariant::BinaryOperatorStrictNeq: + case BinVariant::BinaryOperatorStrictNeq: return BinaryOperator::StrictNeq; - case BinASTVariant::BinaryOperatorLessThan: + case BinVariant::BinaryOperatorLessThan: return BinaryOperator::LessThan; - case BinASTVariant::BinaryOperatorLeqThan: + case BinVariant::BinaryOperatorLeqThan: return BinaryOperator::LeqThan; - case BinASTVariant::BinaryOperatorGreaterThan: + case BinVariant::BinaryOperatorGreaterThan: return BinaryOperator::GreaterThan; - case BinASTVariant::BinaryOperatorGeqThan: + case BinVariant::BinaryOperatorGeqThan: return BinaryOperator::GeqThan; - case BinASTVariant::BinaryOperatorIn: + case BinVariant::BinaryOperatorIn: return BinaryOperator::In; - case BinASTVariant::BinaryOperatorInstanceof: + case BinVariant::BinaryOperatorInstanceof: return BinaryOperator::Instanceof; - case BinASTVariant::BinaryOperatorLsh: + case BinVariant::BinaryOperatorLsh: return BinaryOperator::Lsh; - case BinASTVariant::BinaryOperatorRsh: + case BinVariant::BinaryOperatorRsh: return BinaryOperator::Rsh; - case BinASTVariant::BinaryOperatorUrsh: + case BinVariant::BinaryOperatorUrsh: return BinaryOperator::Ursh; - case BinASTVariant::BinaryOperatorOrUnaryOperatorPlus: + case BinVariant::BinaryOperatorOrUnaryOperatorPlus: return BinaryOperator::Plus; - case BinASTVariant::BinaryOperatorOrUnaryOperatorMinus: + case BinVariant::BinaryOperatorOrUnaryOperatorMinus: return BinaryOperator::Minus; - case BinASTVariant::BinaryOperatorMul: + case BinVariant::BinaryOperatorMul: return BinaryOperator::Mul; - case BinASTVariant::BinaryOperatorDiv: + case BinVariant::BinaryOperatorDiv: return BinaryOperator::Div; - case BinASTVariant::BinaryOperatorMod: + case BinVariant::BinaryOperatorMod: return BinaryOperator::Mod; - case BinASTVariant::BinaryOperatorPow: + case BinVariant::BinaryOperatorPow: return BinaryOperator::Pow; default: return raiseInvalidVariant("BinaryOperator", variant); @@ -4488,29 +4466,29 @@ BinASTParser::parseCompoundAssignmentOperator() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::CompoundAssignmentOperatorPlusAssign: + case BinVariant::CompoundAssignmentOperatorPlusAssign: return CompoundAssignmentOperator::PlusAssign; - case BinASTVariant::CompoundAssignmentOperatorMinusAssign: + case BinVariant::CompoundAssignmentOperatorMinusAssign: return CompoundAssignmentOperator::MinusAssign; - case BinASTVariant::CompoundAssignmentOperatorMulAssign: + case BinVariant::CompoundAssignmentOperatorMulAssign: return CompoundAssignmentOperator::MulAssign; - case BinASTVariant::CompoundAssignmentOperatorDivAssign: + case BinVariant::CompoundAssignmentOperatorDivAssign: return CompoundAssignmentOperator::DivAssign; - case BinASTVariant::CompoundAssignmentOperatorModAssign: + case BinVariant::CompoundAssignmentOperatorModAssign: return CompoundAssignmentOperator::ModAssign; - case BinASTVariant::CompoundAssignmentOperatorPowAssign: + case BinVariant::CompoundAssignmentOperatorPowAssign: return CompoundAssignmentOperator::PowAssign; - case BinASTVariant::CompoundAssignmentOperatorLshAssign: + case BinVariant::CompoundAssignmentOperatorLshAssign: return CompoundAssignmentOperator::LshAssign; - case BinASTVariant::CompoundAssignmentOperatorRshAssign: + case BinVariant::CompoundAssignmentOperatorRshAssign: return CompoundAssignmentOperator::RshAssign; - case BinASTVariant::CompoundAssignmentOperatorUrshAssign: + case BinVariant::CompoundAssignmentOperatorUrshAssign: return CompoundAssignmentOperator::UrshAssign; - case BinASTVariant::CompoundAssignmentOperatorBitOrAssign: + case BinVariant::CompoundAssignmentOperatorBitOrAssign: return CompoundAssignmentOperator::BitOrAssign; - case BinASTVariant::CompoundAssignmentOperatorBitXorAssign: + case BinVariant::CompoundAssignmentOperatorBitXorAssign: return CompoundAssignmentOperator::BitXorAssign; - case BinASTVariant::CompoundAssignmentOperatorBitAndAssign: + case BinVariant::CompoundAssignmentOperatorBitAndAssign: return CompoundAssignmentOperator::BitAndAssign; default: return raiseInvalidVariant("CompoundAssignmentOperator", variant); @@ -4534,19 +4512,19 @@ BinASTParser::parseUnaryOperator() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::BinaryOperatorOrUnaryOperatorPlus: + case BinVariant::BinaryOperatorOrUnaryOperatorPlus: return UnaryOperator::Plus; - case BinASTVariant::BinaryOperatorOrUnaryOperatorMinus: + case BinVariant::BinaryOperatorOrUnaryOperatorMinus: return UnaryOperator::Minus; - case BinASTVariant::UnaryOperatorNot: + case BinVariant::UnaryOperatorNot: return UnaryOperator::Not; - case BinASTVariant::UnaryOperatorBitNot: + case BinVariant::UnaryOperatorBitNot: return UnaryOperator::BitNot; - case BinASTVariant::UnaryOperatorTypeof: + case BinVariant::UnaryOperatorTypeof: return UnaryOperator::Typeof; - case BinASTVariant::UnaryOperatorVoid: + case BinVariant::UnaryOperatorVoid: return UnaryOperator::Void; - case BinASTVariant::UnaryOperatorDelete: + case BinVariant::UnaryOperatorDelete: return UnaryOperator::Delete; default: return raiseInvalidVariant("UnaryOperator", variant); @@ -4565,9 +4543,9 @@ BinASTParser::parseUpdateOperator() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::UpdateOperatorIncr: + case BinVariant::UpdateOperatorIncr: return UpdateOperator::Incr; - case BinASTVariant::UpdateOperatorDecr: + case BinVariant::UpdateOperatorDecr: return UpdateOperator::Decr; default: return raiseInvalidVariant("UpdateOperator", variant); @@ -4587,11 +4565,11 @@ BinASTParser::parseVariableDeclarationKind() { BINJS_MOZ_TRY_DECL(variant, tokenizer_->readVariant()); switch (variant) { - case BinASTVariant::AssertedDeclaredKindOrVariableDeclarationKindVar: + case BinVariant::AssertedDeclaredKindOrVariableDeclarationKindVar: return VariableDeclarationKind::Var; - case BinASTVariant::VariableDeclarationKindLet: + case BinVariant::VariableDeclarationKindLet: return VariableDeclarationKind::Let; - case BinASTVariant::VariableDeclarationKindConst: + case BinVariant::VariableDeclarationKindConst: return VariableDeclarationKind::Const; default: return raiseInvalidVariant("VariableDeclarationKind", variant); @@ -4845,13 +4823,13 @@ JS::Result BinASTParser::parseListOfVariableDeclarator( // ----- Default values (by lexicographical order) template JS::Result BinASTParser::parseOptionalBinding() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; } else { const auto start = tokenizer_->offset(); @@ -4864,15 +4842,15 @@ JS::Result BinASTParser::parseOptionalBinding() { template JS::Result BinASTParser::parseOptionalBindingIdentifier() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; - } else if (kind == BinASTKind::BindingIdentifier) { + } else if (kind == BinKind::BindingIdentifier) { const auto start = tokenizer_->offset(); MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields)); } else { @@ -4885,15 +4863,15 @@ JS::Result BinASTParser::parseOptionalBindingIdentifier() { template JS::Result BinASTParser::parseOptionalCatchClause() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); LexicalScopeNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; - } else if (kind == BinASTKind::CatchClause) { + } else if (kind == BinKind::CatchClause) { const auto start = tokenizer_->offset(); MOZ_TRY_VAR(result, parseInterfaceCatchClause(start, kind, fields)); } else { @@ -4906,13 +4884,13 @@ JS::Result BinASTParser::parseOptionalCatchClause() { template JS::Result BinASTParser::parseOptionalExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; } else { const auto start = tokenizer_->offset(); @@ -4926,13 +4904,13 @@ JS::Result BinASTParser::parseOptionalExpression() { template JS::Result BinASTParser::parseOptionalSpreadElementOrExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; } else { const auto start = tokenizer_->offset(); @@ -4945,13 +4923,13 @@ BinASTParser::parseOptionalSpreadElementOrExpression() { template JS::Result BinASTParser::parseOptionalStatement() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; } else { const auto start = tokenizer_->offset(); @@ -4965,13 +4943,13 @@ JS::Result BinASTParser::parseOptionalStatement() { template JS::Result BinASTParser::parseOptionalVariableDeclarationOrExpression() { - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); ParseNode* result; - if (kind == BinASTKind::_Null) { + if (kind == BinKind::_Null) { result = nullptr; } else { const auto start = tokenizer_->offset(); @@ -4986,7 +4964,7 @@ BinASTParser::parseOptionalVariableDeclarationOrExpression() { // 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; +template class BinASTParser; } // namespace frontend } // namespace js diff --git a/js/src/frontend/BinASTParser.h b/js/src/frontend/BinASTParser.h index ee6b6322fe41..04675a37eab6 100644 --- a/js/src/frontend/BinASTParser.h +++ b/js/src/frontend/BinASTParser.h @@ -7,7 +7,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in -// js/src/frontend/binast/README.md. +// js/src/frontend/binsource/README.md. #ifndef frontend_BinASTParser_h #define frontend_BinASTParser_h @@ -16,8 +16,8 @@ #include "frontend/BCEParserHandle.h" #include "frontend/BinASTParserPerTokenizer.h" -#include "frontend/BinASTToken.h" -#include "frontend/BinASTTokenReaderMultipart.h" +#include "frontend/BinToken.h" +#include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseContext.h" #include "frontend/ParseNode.h" @@ -38,7 +38,7 @@ class BinASTParser : public BinASTParserPerTokenizer { using Tokenizer = Tok; - using BinASTFields = typename Tokenizer::BinASTFields; + using BinFields = typename Tokenizer::BinFields; using AutoList = typename Tokenizer::AutoList; using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple; using Chars = typename Tokenizer::Chars; @@ -135,44 +135,42 @@ class BinASTParser : public BinASTParserPerTokenizer { JS::Result parseSpreadElementOrExpression(); JS::Result parseStatement(); JS::Result parseSumAssertedMaybePositionalParameterName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind, MutableHandle> positionalParams); JS::Result parseSumAssignmentTarget(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseSumBinding(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseSumBinding(const size_t start, const BinKind kind, + const BinFields& fields); JS::Result parseSumExpression(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseSumExpressionOrSuper(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseSumForInOfBindingOrAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseSumObjectProperty(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseSumParameter(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseSumProgram(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseSumProgram(const size_t start, const BinKind kind, + const BinFields& fields); JS::Result parseSumPropertyName(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseSumSimpleAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseSumSpreadElementOrExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseSumStatement(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseSumVariableDeclarationOrExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); // ----- Interfaces (by lexicographical order) // `ParseNode*` may never be nullptr @@ -204,229 +202,252 @@ class BinASTParser : public BinASTParserPerTokenizer { JS::Result parseSwitchDefault(); JS::Result parseVariableDeclarator(); JS::Result parseInterfaceArrayAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceArrayBinding(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceArrayExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceArrayExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceAssertedBlockScope(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceAssertedBoundName(const size_t start, - const BinASTKind kind, - const BinASTFields& fields, + const BinKind kind, + const BinFields& fields, AssertedScopeKind scopeKind); - JS::Result parseInterfaceAssertedBoundNamesScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + JS::Result parseInterfaceAssertedBoundNamesScope(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceAssertedDeclaredName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind); JS::Result parseInterfaceAssertedParameterScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, MutableHandle> positionalParams); JS::Result parseInterfaceAssertedPositionalParameterName( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, AssertedScopeKind scopeKind, MutableHandle> positionalParams); JS::Result parseInterfaceAssertedScriptGlobalScope( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceAssertedVarScope(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceAssignmentExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceAssignmentTargetIdentifier( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceAwaitExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceAwaitExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceBinaryExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceBindingIdentifier( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceBindingWithInitializer( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceBlock(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceBreakStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceCallExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceBreakStatement(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceCallExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceCatchClause( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceClassDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceClassExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceClassExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceCompoundAssignmentExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceComputedMemberAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceComputedMemberExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceComputedPropertyName( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceConditionalExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceContinueStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceDataProperty(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceDebuggerStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceDirective(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceDoWhileStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceEagerArrowExpressionWithExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceEagerArrowExpressionWithFunctionBody( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceEagerFunctionDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceEagerFunctionExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceEagerGetter(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceEagerMethod(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceEagerSetter(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceEmptyStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceEmptyStatement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceExpressionStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceForInOfBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceForInStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceForOfStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceForInOfBinding(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceForInStatement(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceForOfStatement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceForStatement(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceFormalParameters( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceFormalParameters(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceFunctionExpressionContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut); JS::Result parseInterfaceFunctionOrMethodContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut); JS::Result parseInterfaceGetterContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut); JS::Result parseInterfaceIdentifierExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceIfStatement(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceLabelledStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLazyArrowExpressionWithExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLazyArrowExpressionWithFunctionBody( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLazyFunctionDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLazyFunctionExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLazyGetter(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceLazyMethod(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceLazySetter(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceLiteralBooleanExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralInfinityExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralNullExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralNumericExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralPropertyName( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralRegExpExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceLiteralStringExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceModule(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceNewExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceNewExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceNewTargetExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceObjectAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceObjectBinding( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceObjectBinding(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceObjectExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceReturnStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceReturnStatement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceScript(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceSetterContents( - const size_t start, const BinASTKind kind, const BinASTFields& fields, + const size_t start, const BinKind kind, const BinFields& fields, uint32_t funLength, ListNode** paramsOut, ListNode** bodyOut); JS::Result parseInterfaceShorthandProperty( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceSpreadElement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceSpreadElement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceStaticMemberAssignmentTarget( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceStaticMemberExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceSuper(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceSwitchCase(const size_t start, - const BinASTKind kind, - const BinASTFields& fields); - JS::Result parseInterfaceSwitchDefault( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceSwitchStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceSwitchDefault(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceSwitchStatement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceSwitchStatementWithDefault( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceTemplateExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceThisExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceThrowStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceThisExpression(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceThrowStatement(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceTryCatchStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceTryFinallyStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceUnaryExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceUnaryExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceUpdateExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceVariableDeclaration( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); JS::Result parseInterfaceVariableDeclarator( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceWhileStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceWithStatement( - const size_t start, const BinASTKind kind, const BinASTFields& fields); - JS::Result parseInterfaceYieldExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); + JS::Result parseInterfaceWhileStatement(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceWithStatement(const size_t start, + const BinKind kind, + const BinFields& fields); + JS::Result parseInterfaceYieldExpression(const size_t start, + const BinKind kind, + const BinFields& fields); JS::Result parseInterfaceYieldStarExpression( - const size_t start, const BinASTKind kind, const BinASTFields& fields); + const size_t start, const BinKind kind, const BinFields& fields); // ----- String enums (by lexicographical order) JS::Result::AssertedDeclaredKind> @@ -466,7 +487,7 @@ class BinASTParser : public BinASTParserPerTokenizer { JS::Result parseOptionalVariableDeclarationOrExpression(); }; -extern template class BinASTParser; +extern template class BinASTParser; } // namespace frontend } // namespace js diff --git a/js/src/frontend/BinASTParserPerTokenizer.cpp b/js/src/frontend/BinASTParserPerTokenizer.cpp index 1cd557014262..b7267299d68b 100644 --- a/js/src/frontend/BinASTParserPerTokenizer.cpp +++ b/js/src/frontend/BinASTParserPerTokenizer.cpp @@ -14,9 +14,9 @@ #include "mozilla/ScopeExit.h" #include "mozilla/Vector.h" -#include "frontend/BinAST-macros.h" #include "frontend/BinASTParser.h" -#include "frontend/BinASTTokenReaderMultipart.h" +#include "frontend/BinSource-macros.h" +#include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseNode.h" #include "frontend/Parser.h" @@ -118,8 +118,7 @@ JS::Result BinASTParserPerTokenizer::parseAux( tokenizer_.emplace(cx_, this, start, length); - BinASTParseContext globalpc(cx_, this, globalsc, - /* newDirectives = */ nullptr); + BinParseContext globalpc(cx_, this, globalsc, /* newDirectives = */ nullptr); if (!globalpc.init()) { return cx_->alreadyReportedError(); } @@ -180,7 +179,7 @@ JS::Result BinASTParserPerTokenizer::parseLazyFunction( // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -197,9 +196,9 @@ JS::Result BinASTParserPerTokenizer::parseLazyFunction( NewLexicalScopeData(cx_, lexicalScope, alloc_, pc_)); BINJS_TRY_DECL(body, handler_.newLexicalScope(*lexicalScopeData, tmpBody)); - auto binASTKind = isExpr ? BinASTKind::LazyFunctionExpression - : BinASTKind::LazyFunctionDeclaration; - return buildFunction(firstOffset, binASTKind, nullptr, params, body); + auto binKind = isExpr ? BinKind::LazyFunctionExpression + : BinKind::LazyFunctionDeclaration; + return buildFunction(firstOffset, binKind, nullptr, params, body); } template @@ -275,29 +274,29 @@ JS::Result BinASTParserPerTokenizer::buildFunctionBox( return funbox; } -FunctionSyntaxKind BinASTKindToFunctionSyntaxKind(const BinASTKind kind) { +FunctionSyntaxKind BinKindToFunctionSyntaxKind(const BinKind kind) { // FIXME: this doesn't cover FunctionSyntaxKind::ClassConstructor and // FunctionSyntaxKind::DerivedClassConstructor. switch (kind) { - case BinASTKind::EagerFunctionDeclaration: - case BinASTKind::LazyFunctionDeclaration: + case BinKind::EagerFunctionDeclaration: + case BinKind::LazyFunctionDeclaration: return FunctionSyntaxKind::Statement; - case BinASTKind::EagerFunctionExpression: - case BinASTKind::LazyFunctionExpression: + case BinKind::EagerFunctionExpression: + case BinKind::LazyFunctionExpression: return FunctionSyntaxKind::Expression; - case BinASTKind::EagerArrowExpressionWithFunctionBody: - case BinASTKind::LazyArrowExpressionWithFunctionBody: - case BinASTKind::EagerArrowExpressionWithExpression: - case BinASTKind::LazyArrowExpressionWithExpression: + case BinKind::EagerArrowExpressionWithFunctionBody: + case BinKind::LazyArrowExpressionWithFunctionBody: + case BinKind::EagerArrowExpressionWithExpression: + case BinKind::LazyArrowExpressionWithExpression: return FunctionSyntaxKind::Arrow; - case BinASTKind::EagerMethod: - case BinASTKind::LazyMethod: + case BinKind::EagerMethod: + case BinKind::LazyMethod: return FunctionSyntaxKind::Method; - case BinASTKind::EagerGetter: - case BinASTKind::LazyGetter: + case BinKind::EagerGetter: + case BinKind::LazyGetter: return FunctionSyntaxKind::Getter; - case BinASTKind::EagerSetter: - case BinASTKind::LazySetter: + case BinKind::EagerSetter: + case BinKind::LazySetter: return FunctionSyntaxKind::Setter; default: MOZ_CRASH("Invalid/ kind"); @@ -306,10 +305,10 @@ FunctionSyntaxKind BinASTKindToFunctionSyntaxKind(const BinASTKind kind) { template JS::Result BinASTParserPerTokenizer::makeEmptyFunctionNode( - const size_t start, const BinASTKind kind, FunctionBox* funbox) { + const size_t start, const BinKind kind, FunctionBox* funbox) { // LazyScript compilation requires basically none of the fields filled out. TokenPos pos = tokenizer_->pos(start); - FunctionSyntaxKind syntaxKind = BinASTKindToFunctionSyntaxKind(kind); + FunctionSyntaxKind syntaxKind = BinKindToFunctionSyntaxKind(kind); BINJS_TRY_DECL(result, handler_.newFunction(syntaxKind, pos)); @@ -320,8 +319,8 @@ JS::Result BinASTParserPerTokenizer::makeEmptyFunctionNode( template JS::Result BinASTParserPerTokenizer::buildFunction( - const size_t start, const BinASTKind kind, ParseNode* name, - ListNode* params, ParseNode* body) { + const size_t start, const BinKind kind, ParseNode* name, ListNode* params, + ParseNode* body) { FunctionBox* funbox = pc_->functionBox(); // Set the argument count for building argument packets. Function.length is @@ -683,22 +682,22 @@ BinASTParserPerTokenizer::raiseMissingDirectEvalInAssertedScope() { template mozilla::GenericErrorResult BinASTParserPerTokenizer::raiseInvalidKind(const char* superKind, - const BinASTKind kind) { + const BinKind kind) { Sprinter out(cx_); BINJS_TRY(out.init()); - BINJS_TRY(out.printf("In %s, invalid kind %s", superKind, - describeBinASTKind(kind))); + BINJS_TRY( + out.printf("In %s, invalid kind %s", superKind, describeBinKind(kind))); return raiseError(out.string()); } template mozilla::GenericErrorResult BinASTParserPerTokenizer::raiseInvalidVariant(const char* kind, - const BinASTVariant value) { + const BinVariant value) { Sprinter out(cx_); BINJS_TRY(out.init()); BINJS_TRY(out.printf("In %s, invalid variant '%s'", kind, - describeBinASTVariant(value))); + describeBinVariant(value))); return raiseError(out.string()); } @@ -706,11 +705,11 @@ BinASTParserPerTokenizer::raiseInvalidVariant(const char* kind, template mozilla::GenericErrorResult BinASTParserPerTokenizer::raiseMissingField(const char* kind, - const BinASTField field) { + const BinField field) { Sprinter out(cx_); BINJS_TRY(out.init()); - BINJS_TRY(out.printf("In %s, missing field '%s'", kind, - describeBinASTField(field))); + BINJS_TRY( + out.printf("In %s, missing field '%s'", kind, describeBinField(field))); return raiseError(out.string()); } @@ -733,11 +732,11 @@ BinASTParserPerTokenizer::raiseOOM() { template mozilla::GenericErrorResult -BinASTParserPerTokenizer::raiseError(BinASTKind kind, +BinASTParserPerTokenizer::raiseError(BinKind kind, const char* description) { Sprinter out(cx_); BINJS_TRY(out.init()); - BINJS_TRY(out.printf("In %s, %s", describeBinASTKind(kind), description)); + BINJS_TRY(out.printf("In %s, %s", describeBinKind(kind), description)); return tokenizer_->raiseError(out.string()); } @@ -806,7 +805,7 @@ BinASTParserPerTokenizer::asFinalParser() const { // 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 BinASTParserPerTokenizer; +template class BinASTParserPerTokenizer; } // namespace frontend } // namespace js diff --git a/js/src/frontend/BinASTParserPerTokenizer.h b/js/src/frontend/BinASTParserPerTokenizer.h index 02db3332c0e8..cd98e304aa1c 100644 --- a/js/src/frontend/BinASTParserPerTokenizer.h +++ b/js/src/frontend/BinASTParserPerTokenizer.h @@ -19,8 +19,8 @@ #include "frontend/BCEParserHandle.h" #include "frontend/BinASTEnum.h" #include "frontend/BinASTParserBase.h" -#include "frontend/BinASTToken.h" -#include "frontend/BinASTTokenReaderMultipart.h" +#include "frontend/BinToken.h" +#include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseContext.h" #include "frontend/ParseNode.h" @@ -54,7 +54,7 @@ class BinASTParserPerTokenizer : public BinASTParserBase, using AutoList = typename Tokenizer::AutoList; using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple; - using BinASTFields = typename Tokenizer::BinASTFields; + using BinFields = typename Tokenizer::BinFields; using Chars = typename Tokenizer::Chars; public: @@ -106,18 +106,18 @@ class BinASTParserPerTokenizer : public BinASTParserBase, MOZ_MUST_USE mozilla::GenericErrorResult raiseMissingDirectEvalInAssertedScope(); MOZ_MUST_USE mozilla::GenericErrorResult raiseInvalidKind( - const char* superKind, const BinASTKind kind); + const char* superKind, const BinKind kind); MOZ_MUST_USE mozilla::GenericErrorResult raiseInvalidVariant( - const char* kind, const BinASTVariant value); + const char* kind, const BinVariant value); MOZ_MUST_USE mozilla::GenericErrorResult raiseMissingField( - const char* kind, const BinASTField field); + const char* kind, const BinField field); MOZ_MUST_USE mozilla::GenericErrorResult raiseEmpty( const char* description); MOZ_MUST_USE mozilla::GenericErrorResult raiseOOM(); MOZ_MUST_USE mozilla::GenericErrorResult raiseError( const char* description); MOZ_MUST_USE mozilla::GenericErrorResult raiseError( - BinASTKind kind, const char* description); + BinKind kind, const char* description); // Ensure that this parser will never be used again. void poison(); @@ -136,13 +136,12 @@ class BinASTParserPerTokenizer : public BinASTParserBase, // Build a function object for a function-producing production. Called AFTER // creating the scope. JS::Result makeEmptyFunctionNode(const size_t start, - const BinASTKind kind, + const BinKind kind, FunctionBox* funbox); JS::Result buildFunction(const size_t start, - const BinASTKind kind, - ParseNode* name, ListNode* params, - ParseNode* body); + const BinKind kind, ParseNode* name, + ListNode* params, ParseNode* body); JS::Result buildFunctionBox(GeneratorKind generatorKind, FunctionAsyncKind functionAsyncKind, FunctionSyntaxKind syntax, @@ -285,7 +284,7 @@ class BinASTParserPerTokenizer : public BinASTParserBase, mozilla::Maybe tokenizer_; VariableDeclarationKind variableDeclarationKind_; - friend class BinASTParseContext; + friend class BinParseContext; friend class AutoVariableDeclarationKind; // Helper class: Restore field `variableDeclarationKind` upon leaving a scope. @@ -315,18 +314,18 @@ class BinASTParserPerTokenizer : public BinASTParserBase, inline const FinalParser* asFinalParser() const; }; -class BinASTParseContext : public ParseContext { +class BinParseContext : public ParseContext { public: template - BinASTParseContext(JSContext* cx, BinASTParserPerTokenizer* parser, - SharedContext* sc, Directives* newDirectives) + BinParseContext(JSContext* cx, BinASTParserPerTokenizer* parser, + SharedContext* sc, Directives* newDirectives) : ParseContext(cx, parser->pc_, sc, *parser, parser->usedNames_, newDirectives, /* isFull = */ true) {} }; void TraceBinASTParser(JSTracer* trc, JS::AutoGCRooter* parser); -extern template class BinASTParserPerTokenizer; +extern template class BinASTParserPerTokenizer; } // namespace frontend } // namespace js diff --git a/js/src/frontend/BinASTToken.cpp b/js/src/frontend/BinASTToken.cpp deleted file mode 100644 index 7b015d3f18e0..000000000000 --- a/js/src/frontend/BinASTToken.cpp +++ /dev/null @@ -1,155 +0,0 @@ -/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- - * vim: set ts=8 sts=2 et sw=2 tw=80: - * 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/BinASTToken.h" - -#include "mozilla/Maybe.h" - -#include - -#include "frontend/BinASTRuntimeSupport.h" -#include "frontend/TokenStream.h" -#include "js/Result.h" -#include "vm/JSContext.h" - -namespace js { -namespace frontend { - -const BinaryASTSupport::CharSlice BINASTKIND_DESCRIPTIONS[] = { -#define WITH_VARIANT(_, SPEC_NAME) \ - BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), - FOR_EACH_BIN_KIND(WITH_VARIANT) -#undef WITH_VARIANT -}; - -const BinaryASTSupport::CharSlice BINASTFIELD_DESCRIPTIONS[] = { -#define WITH_VARIANT(_, SPEC_NAME) \ - BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), - FOR_EACH_BIN_FIELD(WITH_VARIANT) -#undef WITH_VARIANT -}; - -const BinaryASTSupport::CharSlice BINASTVARIANT_DESCRIPTIONS[] = { -#define WITH_VARIANT(_, SPEC_NAME) \ - BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), - FOR_EACH_BIN_VARIANT(WITH_VARIANT) -#undef WITH_VARIANT -}; - -const BinaryASTSupport::CharSlice& getBinASTKind(const BinASTKind& variant) { - return BINASTKIND_DESCRIPTIONS[static_cast(variant)]; -} - -const BinaryASTSupport::CharSlice& getBinASTVariant( - const BinASTVariant& variant) { - return BINASTVARIANT_DESCRIPTIONS[static_cast(variant)]; -} - -const BinaryASTSupport::CharSlice& getBinASTField(const BinASTField& variant) { - return BINASTFIELD_DESCRIPTIONS[static_cast(variant)]; -} - -const char* describeBinASTKind(const BinASTKind& variant) { - return getBinASTKind(variant).begin(); -} - -const char* describeBinASTField(const BinASTField& variant) { - return getBinASTField(variant).begin(); -} - -const char* describeBinASTVariant(const BinASTVariant& variant) { - return getBinASTVariant(variant).begin(); -} - -} // namespace frontend - -BinaryASTSupport::BinaryASTSupport() - : binASTKindMap_(frontend::BINASTKIND_LIMIT), - binASTFieldMap_(frontend::BINASTFIELD_LIMIT), - binASTVariantMap_(frontend::BINASTVARIANT_LIMIT) {} - -/** - * It is expected that all bin tables are initialized on the main thread, and - * that any helper threads will find the read-only tables properly initialized, - * so that they can do their accesses safely without taking any locks. - */ -bool BinaryASTSupport::ensureBinTablesInitialized(JSContext* cx) { - return ensureBinASTKindsInitialized(cx) && - ensureBinASTVariantsInitialized(cx); -} - -bool BinaryASTSupport::ensureBinASTKindsInitialized(JSContext* cx) { - MOZ_ASSERT(!cx->helperThread()); - if (binASTKindMap_.empty()) { - for (size_t i = 0; i < frontend::BINASTKIND_LIMIT; ++i) { - const BinASTKind variant = static_cast(i); - const CharSlice& key = getBinASTKind(variant); - auto ptr = binASTKindMap_.lookupForAdd(key); - MOZ_ASSERT(!ptr); - if (!binASTKindMap_.add(ptr, key, variant)) { - ReportOutOfMemory(cx); - return false; - } - } - } - - return true; -} - -bool BinaryASTSupport::ensureBinASTVariantsInitialized(JSContext* cx) { - MOZ_ASSERT(!cx->helperThread()); - if (binASTVariantMap_.empty()) { - for (size_t i = 0; i < frontend::BINASTVARIANT_LIMIT; ++i) { - const BinASTVariant variant = static_cast(i); - const CharSlice& key = getBinASTVariant(variant); - auto ptr = binASTVariantMap_.lookupForAdd(key); - MOZ_ASSERT(!ptr); - if (!binASTVariantMap_.add(ptr, key, variant)) { - ReportOutOfMemory(cx); - return false; - } - } - } - return true; -} - -JS::Result BinaryASTSupport::binASTKind( - JSContext* cx, const CharSlice key) { - MOZ_ASSERT_IF(cx->helperThread(), !binASTKindMap_.empty()); - if (!cx->helperThread()) { - // Initialize Lazily if on main thread. - if (!ensureBinASTKindsInitialized(cx)) { - return cx->alreadyReportedError(); - } - } - - auto ptr = binASTKindMap_.readonlyThreadsafeLookup(key); - if (!ptr) { - return nullptr; - } - - return &ptr->value(); -} - -JS::Result BinaryASTSupport::binASTVariant( - JSContext* cx, const CharSlice key) { - MOZ_ASSERT_IF(cx->helperThread(), !binASTVariantMap_.empty()); - if (!cx->helperThread()) { - // Initialize lazily if on main thread. - if (!ensureBinASTVariantsInitialized(cx)) { - return cx->alreadyReportedError(); - } - } - - auto ptr = binASTVariantMap_.readonlyThreadsafeLookup(key); - if (!ptr) { - return nullptr; - } - - return &ptr->value(); -} - -} // namespace js diff --git a/js/src/frontend/BinAST-macros.h b/js/src/frontend/BinSource-macros.h similarity index 95% rename from js/src/frontend/BinAST-macros.h rename to js/src/frontend/BinSource-macros.h index ab5ef9cad630..a3a2b31b8459 100644 --- a/js/src/frontend/BinAST-macros.h +++ b/js/src/frontend/BinSource-macros.h @@ -4,8 +4,8 @@ * 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/. */ -#ifndef frontend_BinAST_macros_h -#define frontend_BinAST_macros_h +#ifndef frontend_BinSource_macros_h +#define frontend_BinSource_macros_h #include "vm/JSContext.h" @@ -59,4 +59,4 @@ if (_##VAR.isErr()) return ::mozilla::Err(_##VAR.unwrapErr()); \ auto VAR = _##VAR.unwrap(); -#endif // frontend_BinAST_macros_h +#endif // frontend_BinSource_macros_h diff --git a/js/src/frontend/BinAST.webidl_ b/js/src/frontend/BinSource.webidl_ similarity index 100% rename from js/src/frontend/BinAST.webidl_ rename to js/src/frontend/BinSource.webidl_ diff --git a/js/src/frontend/BinAST.yaml b/js/src/frontend/BinSource.yaml similarity index 97% rename from js/src/frontend/BinAST.yaml rename to js/src/frontend/BinSource.yaml index d7f32e4922aa..059404cd4e59 100644 --- a/js/src/frontend/BinAST.yaml +++ b/js/src/frontend/BinSource.yaml @@ -27,7 +27,7 @@ cpp: * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in - // js/src/frontend/binast/README.md. + // js/src/frontend/binsource/README.md. #include "frontend/BinASTParser.h" @@ -38,8 +38,8 @@ cpp: #include "mozilla/PodOperations.h" #include "mozilla/Vector.h" - #include "frontend/BinAST-macros.h" - #include "frontend/BinASTTokenReaderMultipart.h" + #include "frontend/BinSource-macros.h" + #include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseNode.h" #include "frontend/Parser.h" @@ -64,7 +64,7 @@ cpp: // 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; + template class BinASTParser; } // namespace frontend } // namespace js @@ -80,7 +80,7 @@ hpp: * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in - // js/src/frontend/binast/README.md. + // js/src/frontend/binsource/README.md. #ifndef frontend_BinASTParser_h #define frontend_BinASTParser_h @@ -89,8 +89,8 @@ hpp: #include "frontend/BCEParserHandle.h" #include "frontend/BinASTParserPerTokenizer.h" - #include "frontend/BinASTToken.h" - #include "frontend/BinASTTokenReaderMultipart.h" + #include "frontend/BinToken.h" + #include "frontend/BinTokenReaderMultipart.h" #include "frontend/FullParseHandler.h" #include "frontend/ParseContext.h" #include "frontend/ParseNode.h" @@ -111,7 +111,7 @@ hpp: using Tokenizer = Tok; - using BinASTFields = typename Tokenizer::BinASTFields; + using BinFields = typename Tokenizer::BinFields; using AutoList = typename Tokenizer::AutoList; using AutoTaggedTuple = typename Tokenizer::AutoTaggedTuple; using Chars = typename Tokenizer::Chars; @@ -193,7 +193,7 @@ hpp: footer: | }; - extern template class BinASTParser; + extern template class BinASTParser; } // namespace frontend } // namespace js @@ -209,7 +209,7 @@ hpp: * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in - // js/src/frontend/binast/README.md. + // js/src/frontend/binsource/README.md. #ifndef frontend_BinASTEnum_h #define frontend_BinASTEnum_h @@ -224,7 +224,7 @@ hpp: #endif // frontend_BinASTEnum_h - # Rules for generating BinASTToken.h + # Rules for generating BinToken.h tokens: kind: doc: | @@ -287,10 +287,10 @@ hpp: // To generate this file, see the documentation in - // js/src/frontend/binast/README.md. + // js/src/frontend/binsource/README.md. - #ifndef frontend_BinASTToken_h - #define frontend_BinASTToken_h + #ifndef frontend_BinToken_h + #define frontend_BinToken_h #include @@ -299,9 +299,9 @@ hpp: * * In the Binary AST world, an AST is composed of nodes, where a node is * defined by: - * - a Kind (see `BinASTKind`); + * - a Kind (see `BinKind`); * - a list of fields, where each field is: - * - a Name (see `BinASTField`); + * - a Name (see `BinField`); * - a Value, which may be either a node or a primitive value. * * The mapping between Kind and list of fields is determined entirely by @@ -325,24 +325,24 @@ hpp: footer: | /** - * Return a string describing a `BinASTKind`. + * Return a string describing a `BinKind`. */ - const char* describeBinASTKind(const BinASTKind& kind); + const char* describeBinKind(const BinKind& kind); /** - * Return a string describing a `BinASTField`. + * Return a string describing a `BinField`. */ - const char* describeBinASTField(const BinASTField& kind); + const char* describeBinField(const BinField& kind); /** - * Return a string describing a `BinASTVariant`. + * Return a string describing a `BinVariant`. */ - const char* describeBinASTVariant(const BinASTVariant& kind); + const char* describeBinVariant(const BinVariant& kind); } // namespace frontend } // namespace js - #endif // frontend_BinASTToken_h + #endif // frontend_BinToken_h Arguments: init: | @@ -921,7 +921,7 @@ EagerFunctionExpression: // Push a new ParseContext. It will be used to parse `scope`, the arguments, // the function. - BinASTParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); + BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr); BINJS_TRY(funpc.init()); pc_->functionScope().useAsVarScope(pc_); MOZ_ASSERT(pc_->isFunctionBox()); @@ -1615,7 +1615,7 @@ VariableDeclarator: if (!init) { // Here, `init` is required. return raiseMissingField("VariableDeclarator (with non-trivial pattern)", - BinASTField::Init); + BinField::Init); } MOZ_CRASH("Unimplemented: AssertedScope check for BindingPattern variable declaration"); diff --git a/js/src/frontend/BinASTRuntimeSupport.cpp b/js/src/frontend/BinSourceRuntimeSupport.cpp similarity index 68% rename from js/src/frontend/BinASTRuntimeSupport.cpp rename to js/src/frontend/BinSourceRuntimeSupport.cpp index 7f62365c677d..a615377171d9 100644 --- a/js/src/frontend/BinASTRuntimeSupport.cpp +++ b/js/src/frontend/BinSourceRuntimeSupport.cpp @@ -4,7 +4,7 @@ * 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/BinASTRuntimeSupport.h" +#include "frontend/BinSourceRuntimeSupport.h" #include "gc/Tracer.h" #include "js/Vector.h" @@ -15,18 +15,18 @@ namespace frontend { /* static */ BinASTSourceMetadata* BinASTSourceMetadata::Create( - const Vector& binASTKinds, uint32_t numStrings) { - uint32_t numBinASTKinds = binASTKinds.length(); + const Vector& binKinds, uint32_t numStrings) { + uint32_t numBinKinds = binKinds.length(); BinASTSourceMetadata* data = static_cast( - js_malloc(BinASTSourceMetadata::totalSize(numBinASTKinds, numStrings))); + js_malloc(BinASTSourceMetadata::totalSize(numBinKinds, numStrings))); if (!data) { return nullptr; } - new (data) BinASTSourceMetadata(numBinASTKinds, numStrings); - memcpy(data->binASTKindBase(), binASTKinds.begin(), - binASTKinds.length() * sizeof(BinASTKind)); + new (data) BinASTSourceMetadata(numBinKinds, numStrings); + memcpy(data->binKindBase(), binKinds.begin(), + binKinds.length() * sizeof(BinKind)); return data; } diff --git a/js/src/frontend/BinASTRuntimeSupport.h b/js/src/frontend/BinSourceRuntimeSupport.h similarity index 64% rename from js/src/frontend/BinASTRuntimeSupport.h rename to js/src/frontend/BinSourceRuntimeSupport.h index d05631eb33f5..d37638fbd2cb 100644 --- a/js/src/frontend/BinASTRuntimeSupport.h +++ b/js/src/frontend/BinSourceRuntimeSupport.h @@ -4,12 +4,12 @@ * 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/. */ -#ifndef frontend_BinASTSupport_h -#define frontend_BinASTSupport_h +#ifndef frontend_BinSourceSupport_h +#define frontend_BinSourceSupport_h #include "mozilla/HashFunctions.h" -#include "frontend/BinASTToken.h" +#include "frontend/BinToken.h" #include "gc/DeletePolicy.h" #include "js/AllocPolicy.h" @@ -24,9 +24,9 @@ class ScriptSource; // Support for parsing JS Binary ASTs. struct BinaryASTSupport { - using BinASTVariant = js::frontend::BinASTVariant; - using BinASTField = js::frontend::BinASTField; - using BinASTKind = js::frontend::BinASTKind; + using BinVariant = js::frontend::BinVariant; + using BinField = js::frontend::BinField; + using BinKind = js::frontend::BinKind; // A structure designed to perform fast char* + length lookup // without copies. @@ -64,29 +64,29 @@ struct BinaryASTSupport { BinaryASTSupport(); - JS::Result binASTVariant(JSContext*, const CharSlice); - JS::Result binASTKind(JSContext*, const CharSlice); + JS::Result binVariant(JSContext*, const CharSlice); + JS::Result binKind(JSContext*, const CharSlice); bool ensureBinTablesInitialized(JSContext*); private: - bool ensureBinASTKindsInitialized(JSContext*); - bool ensureBinASTVariantsInitialized(JSContext*); + bool ensureBinKindsInitialized(JSContext*); + bool ensureBinVariantsInitialized(JSContext*); private: // A HashMap that can be queried without copies from a CharSlice key. // Initialized on first call. Keys are CharSlices into static strings. - using BinASTKindMap = js::HashMap; + BinKindMap binKindMap_; + + using BinFieldMap = + js::HashMap; + BinFieldMap binFieldMap_; + + using BinVariantMap = js::HashMap; - BinASTKindMap binASTKindMap_; - - using BinASTFieldMap = js::HashMap; - BinASTFieldMap binASTFieldMap_; - - using BinASTVariantMap = js::HashMap; - BinASTVariantMap binASTVariantMap_; + BinVariantMap binVariantMap_; }; namespace frontend { @@ -95,7 +95,7 @@ class BinASTSourceMetadata { using CharSlice = BinaryASTSupport::CharSlice; const uint32_t numStrings_; - const uint32_t numBinASTKinds_; + const uint32_t numBinKinds_; // The data lives inline in the allocation, after this class. inline JSAtom** atomsBase() { @@ -106,33 +106,32 @@ class BinASTSourceMetadata { reinterpret_cast(atomsBase()) + numStrings_ * sizeof(JSAtom*)); } - inline BinASTKind* binASTKindBase() { - return reinterpret_cast( - reinterpret_cast(sliceBase()) + - numStrings_ * sizeof(CharSlice)); + inline BinKind* binKindBase() { + return reinterpret_cast(reinterpret_cast(sliceBase()) + + numStrings_ * sizeof(CharSlice)); } - static inline size_t totalSize(uint32_t numBinASTKinds, uint32_t numStrings) { + static inline size_t totalSize(uint32_t numBinKinds, uint32_t numStrings) { return sizeof(BinASTSourceMetadata) + numStrings * sizeof(JSAtom*) + - numStrings * sizeof(CharSlice) + numBinASTKinds * sizeof(BinASTKind); + numStrings * sizeof(CharSlice) + numBinKinds * sizeof(BinKind); } - BinASTSourceMetadata(uint32_t numBinASTKinds, uint32_t numStrings) - : numStrings_(numStrings), numBinASTKinds_(numBinASTKinds) {} + BinASTSourceMetadata(uint32_t numBinKinds, uint32_t numStrings) + : numStrings_(numStrings), numBinKinds_(numBinKinds) {} friend class js::ScriptSource; public: - static BinASTSourceMetadata* Create(const Vector& binASTKinds, + static BinASTSourceMetadata* Create(const Vector& binKinds, uint32_t numStrings); - inline uint32_t numBinASTKinds() { return numBinASTKinds_; } + inline uint32_t numBinKinds() { return numBinKinds_; } inline uint32_t numStrings() { return numStrings_; } - inline BinASTKind& getBinASTKind(uint32_t index) { - MOZ_ASSERT(index < numBinASTKinds_); - return binASTKindBase()[index]; + inline BinKind& getBinKind(uint32_t index) { + MOZ_ASSERT(index < numBinKinds_); + return binKindBase()[index]; } inline CharSlice& getSlice(uint32_t index) { @@ -156,4 +155,4 @@ typedef UniquePtr + +#include "frontend/BinSourceRuntimeSupport.h" +#include "frontend/TokenStream.h" +#include "js/Result.h" +#include "vm/JSContext.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 +}; + +const BinaryASTSupport::CharSlice BINFIELD_DESCRIPTIONS[] = { +#define WITH_VARIANT(_, SPEC_NAME) \ + BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), + FOR_EACH_BIN_FIELD(WITH_VARIANT) +#undef WITH_VARIANT +}; + +const BinaryASTSupport::CharSlice BINVARIANT_DESCRIPTIONS[] = { +#define WITH_VARIANT(_, SPEC_NAME) \ + BinaryASTSupport::CharSlice(SPEC_NAME, sizeof(SPEC_NAME) - 1), + FOR_EACH_BIN_VARIANT(WITH_VARIANT) +#undef WITH_VARIANT +}; + +const BinaryASTSupport::CharSlice& getBinKind(const BinKind& variant) { + return BINKIND_DESCRIPTIONS[static_cast(variant)]; +} + +const BinaryASTSupport::CharSlice& getBinVariant(const BinVariant& variant) { + return BINVARIANT_DESCRIPTIONS[static_cast(variant)]; +} + +const BinaryASTSupport::CharSlice& getBinField(const BinField& variant) { + return BINFIELD_DESCRIPTIONS[static_cast(variant)]; +} + +const char* describeBinKind(const BinKind& variant) { + return getBinKind(variant).begin(); +} + +const char* describeBinField(const BinField& variant) { + return getBinField(variant).begin(); +} + +const char* describeBinVariant(const BinVariant& variant) { + return getBinVariant(variant).begin(); +} + +} // namespace frontend + +BinaryASTSupport::BinaryASTSupport() + : binKindMap_(frontend::BINKIND_LIMIT), + binFieldMap_(frontend::BINFIELD_LIMIT), + binVariantMap_(frontend::BINVARIANT_LIMIT) {} + +/** + * It is expected that all bin tables are initialized on the main thread, and + * that any helper threads will find the read-only tables properly initialized, + * so that they can do their accesses safely without taking any locks. + */ +bool BinaryASTSupport::ensureBinTablesInitialized(JSContext* cx) { + return ensureBinKindsInitialized(cx) && ensureBinVariantsInitialized(cx); +} + +bool BinaryASTSupport::ensureBinKindsInitialized(JSContext* cx) { + MOZ_ASSERT(!cx->helperThread()); + if (binKindMap_.empty()) { + for (size_t i = 0; i < frontend::BINKIND_LIMIT; ++i) { + const BinKind variant = static_cast(i); + const CharSlice& key = getBinKind(variant); + auto ptr = binKindMap_.lookupForAdd(key); + MOZ_ASSERT(!ptr); + if (!binKindMap_.add(ptr, key, variant)) { + ReportOutOfMemory(cx); + return false; + } + } + } + + return true; +} + +bool BinaryASTSupport::ensureBinVariantsInitialized(JSContext* cx) { + MOZ_ASSERT(!cx->helperThread()); + if (binVariantMap_.empty()) { + for (size_t i = 0; i < frontend::BINVARIANT_LIMIT; ++i) { + const BinVariant variant = static_cast(i); + const CharSlice& key = getBinVariant(variant); + auto ptr = binVariantMap_.lookupForAdd(key); + MOZ_ASSERT(!ptr); + if (!binVariantMap_.add(ptr, key, variant)) { + ReportOutOfMemory(cx); + return false; + } + } + } + return true; +} + +JS::Result BinaryASTSupport::binKind( + JSContext* cx, const CharSlice key) { + MOZ_ASSERT_IF(cx->helperThread(), !binKindMap_.empty()); + if (!cx->helperThread()) { + // Initialize Lazily if on main thread. + if (!ensureBinKindsInitialized(cx)) { + return cx->alreadyReportedError(); + } + } + + auto ptr = binKindMap_.readonlyThreadsafeLookup(key); + if (!ptr) { + return nullptr; + } + + return &ptr->value(); +} + +JS::Result BinaryASTSupport::binVariant( + JSContext* cx, const CharSlice key) { + MOZ_ASSERT_IF(cx->helperThread(), !binVariantMap_.empty()); + if (!cx->helperThread()) { + // Initialize lazily if on main thread. + if (!ensureBinVariantsInitialized(cx)) { + return cx->alreadyReportedError(); + } + } + + auto ptr = binVariantMap_.readonlyThreadsafeLookup(key); + if (!ptr) { + return nullptr; + } + + return &ptr->value(); +} + +} // namespace js diff --git a/js/src/frontend/BinASTToken.h b/js/src/frontend/BinToken.h similarity index 95% rename from js/src/frontend/BinASTToken.h rename to js/src/frontend/BinToken.h index c13bbc95b79c..dd5b0ba75880 100644 --- a/js/src/frontend/BinASTToken.h +++ b/js/src/frontend/BinToken.h @@ -7,10 +7,10 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // To generate this file, see the documentation in -// js/src/frontend/binast/README.md. +// js/src/frontend/binsource/README.md. -#ifndef frontend_BinASTToken_h -#define frontend_BinASTToken_h +#ifndef frontend_BinToken_h +#define frontend_BinToken_h #include @@ -19,9 +19,9 @@ * * In the Binary AST world, an AST is composed of nodes, where a node is * defined by: - * - a Kind (see `BinASTKind`); + * - a Kind (see `BinKind`); * - a list of fields, where each field is: - * - a Name (see `BinASTField`); + * - a Name (see `BinField`); * - a Value, which may be either a node or a primitive value. * * The mapping between Kind and list of fields is determined entirely by @@ -185,14 +185,14 @@ namespace frontend { F(YieldExpression, "YieldExpression") \ F(YieldStarExpression, "YieldStarExpression") -enum class BinASTKind { +enum class BinKind { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_KIND(EMIT_ENUM) #undef EMIT_ENUM }; -// The number of distinct values of BinASTKind. -const size_t BINASTKIND_LIMIT = 120; +// The number of distinct values of BinKind. +const size_t BINKIND_LIMIT = 120; /** * The different fields of Binary AST nodes, as per the specifications of @@ -278,14 +278,14 @@ const size_t BINASTKIND_LIMIT = 120; F(Update, "update") \ F(Value, "value") -enum class BinASTField { +enum class BinField { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_FIELD(EMIT_ENUM) #undef EMIT_ENUM }; -// The number of distinct values of BinASTField. -const size_t BINASTFIELD_LIMIT = 69; +// The number of distinct values of BinField. +const size_t BINFIELD_LIMIT = 69; /** * The different variants of Binary AST string enums, as per @@ -354,31 +354,31 @@ const size_t BINASTFIELD_LIMIT = 69; F(VariableDeclarationKindConst, "const") \ F(VariableDeclarationKindLet, "let") -enum class BinASTVariant { +enum class BinVariant { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_VARIANT(EMIT_ENUM) #undef EMIT_ENUM }; -// The number of distinct values of BinASTVariant. -const size_t BINASTVARIANT_LIMIT = 49; +// The number of distinct values of BinVariant. +const size_t BINVARIANT_LIMIT = 49; /** - * Return a string describing a `BinASTKind`. + * Return a string describing a `BinKind`. */ -const char* describeBinASTKind(const BinASTKind& kind); +const char* describeBinKind(const BinKind& kind); /** - * Return a string describing a `BinASTField`. + * Return a string describing a `BinField`. */ -const char* describeBinASTField(const BinASTField& kind); +const char* describeBinField(const BinField& kind); /** - * Return a string describing a `BinASTVariant`. + * Return a string describing a `BinVariant`. */ -const char* describeBinASTVariant(const BinASTVariant& kind); +const char* describeBinVariant(const BinVariant& kind); } // namespace frontend } // namespace js -#endif // frontend_BinASTToken_h +#endif // frontend_BinToken_h diff --git a/js/src/frontend/BinASTTokenReaderBase.cpp b/js/src/frontend/BinTokenReaderBase.cpp similarity index 64% rename from js/src/frontend/BinASTTokenReaderBase.cpp rename to js/src/frontend/BinTokenReaderBase.cpp index 02b664c50569..2376a89ff8ca 100644 --- a/js/src/frontend/BinASTTokenReaderBase.cpp +++ b/js/src/frontend/BinTokenReaderBase.cpp @@ -4,9 +4,9 @@ * 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/BinASTTokenReaderBase.h" +#include "frontend/BinTokenReaderBase.h" -#include "frontend/BinAST-macros.h" +#include "frontend/BinSource-macros.h" #include "js/Result.h" namespace js { @@ -19,44 +19,44 @@ using ErrorResult = mozilla::GenericErrorResult; // to represent a `null` number. const uint64_t NULL_FLOAT_REPRESENTATION = 0x7FF0000000000001; -void BinASTTokenReaderBase::updateLatestKnownGood() { +void BinTokenReaderBase::updateLatestKnownGood() { MOZ_ASSERT(current_ >= start_); const size_t update = current_ - start_; MOZ_ASSERT(update >= latestKnownGoodPos_); latestKnownGoodPos_ = update; } -ErrorResult BinASTTokenReaderBase::raiseError( +ErrorResult BinTokenReaderBase::raiseError( const char* description) { MOZ_ASSERT(!hasRaisedError()); errorReporter_->errorNoOffset(JSMSG_BINAST, description); return cx_->alreadyReportedError(); } -ErrorResult BinASTTokenReaderBase::raiseOOM() { +ErrorResult BinTokenReaderBase::raiseOOM() { ReportOutOfMemory(cx_); return cx_->alreadyReportedError(); } -ErrorResult BinASTTokenReaderBase::raiseInvalidNumberOfFields( - const BinASTKind kind, const uint32_t expected, const uint32_t got) { +ErrorResult BinTokenReaderBase::raiseInvalidNumberOfFields( + const BinKind kind, const uint32_t expected, const uint32_t got) { Sprinter out(cx_); BINJS_TRY(out.init()); BINJS_TRY(out.printf("In %s, invalid number of fields: expected %u, got %u", - describeBinASTKind(kind), expected, got)); + describeBinKind(kind), expected, got)); return raiseError(out.string()); } -ErrorResult BinASTTokenReaderBase::raiseInvalidField( - const char* kind, const BinASTField field) { +ErrorResult BinTokenReaderBase::raiseInvalidField( + const char* kind, const BinField field) { Sprinter out(cx_); BINJS_TRY(out.init()); - BINJS_TRY(out.printf("In %s, invalid field '%s'", kind, - describeBinASTField(field))); + BINJS_TRY( + out.printf("In %s, invalid field '%s'", kind, describeBinField(field))); return raiseError(out.string()); } -bool BinASTTokenReaderBase::hasRaisedError() const { +bool BinTokenReaderBase::hasRaisedError() const { if (cx_->helperThread()) { // When performing off-main-thread parsing, we don't set a pending // exception but instead add a pending compile error. @@ -66,11 +66,11 @@ bool BinASTTokenReaderBase::hasRaisedError() const { return cx_->isExceptionPending(); } -size_t BinASTTokenReaderBase::offset() const { return current_ - start_; } +size_t BinTokenReaderBase::offset() const { return current_ - start_; } -TokenPos BinASTTokenReaderBase::pos() { return pos(offset()); } +TokenPos BinTokenReaderBase::pos() { return pos(offset()); } -TokenPos BinASTTokenReaderBase::pos(size_t start) { +TokenPos BinTokenReaderBase::pos(size_t start) { TokenPos pos; pos.begin = start; pos.end = current_ - start_; @@ -78,12 +78,12 @@ TokenPos BinASTTokenReaderBase::pos(size_t start) { return pos; } -void BinASTTokenReaderBase::seek(size_t offset) { +void BinTokenReaderBase::seek(size_t offset) { MOZ_ASSERT(start_ + offset >= start_ && start_ + offset < stop_); current_ = start_ + offset; } -JS::Result BinASTTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) { +JS::Result BinTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) { MOZ_ASSERT(!hasRaisedError()); MOZ_ASSERT(len > 0); @@ -98,7 +98,7 @@ JS::Result BinASTTokenReaderBase::readBuf(uint8_t* bytes, uint32_t len) { return Ok(); } -JS::Result BinASTTokenReaderBase::readByte() { +JS::Result BinTokenReaderBase::readByte() { uint8_t byte; MOZ_TRY(readBuf(&byte, 1)); return byte; diff --git a/js/src/frontend/BinASTTokenReaderBase.h b/js/src/frontend/BinTokenReaderBase.h similarity index 86% rename from js/src/frontend/BinASTTokenReaderBase.h rename to js/src/frontend/BinTokenReaderBase.h index 8708e38d02d0..9221e53776a7 100644 --- a/js/src/frontend/BinASTTokenReaderBase.h +++ b/js/src/frontend/BinTokenReaderBase.h @@ -4,10 +4,10 @@ * 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/. */ -#ifndef frontend_BinASTTokenReaderBase_h -#define frontend_BinASTTokenReaderBase_h +#ifndef frontend_BinTokenReaderBase_h +#define frontend_BinTokenReaderBase_h -#include "frontend/BinASTToken.h" +#include "frontend/BinToken.h" #include "frontend/ErrorReporter.h" #include "frontend/TokenStream.h" @@ -20,7 +20,7 @@ namespace frontend { // A constant used by tokenizers to represent a null float. extern const uint64_t NULL_FLOAT_REPRESENTATION; -class MOZ_STACK_CLASS BinASTTokenReaderBase { +class MOZ_STACK_CLASS BinTokenReaderBase { public: template using ErrorResult = mozilla::GenericErrorResult; @@ -67,13 +67,13 @@ class MOZ_STACK_CLASS BinASTTokenReaderBase { MOZ_MUST_USE ErrorResult raiseError(const char* description); MOZ_MUST_USE ErrorResult raiseOOM(); MOZ_MUST_USE ErrorResult raiseInvalidNumberOfFields( - const BinASTKind kind, const uint32_t expected, const uint32_t got); - MOZ_MUST_USE ErrorResult raiseInvalidField( - const char* kind, const BinASTField field); + const BinKind kind, const uint32_t expected, const uint32_t got); + MOZ_MUST_USE ErrorResult raiseInvalidField(const char* kind, + const BinField field); protected: - BinASTTokenReaderBase(JSContext* cx, ErrorReporter* er, const uint8_t* start, - const size_t length) + BinTokenReaderBase(JSContext* cx, ErrorReporter* er, const uint8_t* start, + const size_t length) : cx_(cx), errorReporter_(er), poisoned_(false), @@ -172,12 +172,12 @@ class MOZ_STACK_CLASS BinASTTokenReaderBase { size_t latestKnownGoodPos_; private: - BinASTTokenReaderBase(const BinASTTokenReaderBase&) = delete; - BinASTTokenReaderBase(BinASTTokenReaderBase&&) = delete; - BinASTTokenReaderBase& operator=(BinASTTokenReaderBase&) = delete; + BinTokenReaderBase(const BinTokenReaderBase&) = delete; + BinTokenReaderBase(BinTokenReaderBase&&) = delete; + BinTokenReaderBase& operator=(BinTokenReaderBase&) = delete; }; } // namespace frontend } // namespace js -#endif // frontend_BinASTTokenReaderBase_h +#endif // frontend_BinTokenReaderBase_h diff --git a/js/src/frontend/BinASTTokenReaderMultipart.cpp b/js/src/frontend/BinTokenReaderMultipart.cpp similarity index 78% rename from js/src/frontend/BinASTTokenReaderMultipart.cpp rename to js/src/frontend/BinTokenReaderMultipart.cpp index f570581bbebe..13b82a015c55 100644 --- a/js/src/frontend/BinASTTokenReaderMultipart.cpp +++ b/js/src/frontend/BinTokenReaderMultipart.cpp @@ -4,7 +4,7 @@ * 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/BinASTTokenReaderMultipart.h" +#include "frontend/BinTokenReaderMultipart.h" #include "mozilla/ArrayUtils.h" #include "mozilla/Casting.h" @@ -14,8 +14,8 @@ #include -#include "frontend/BinAST-macros.h" -#include "frontend/BinASTRuntimeSupport.h" +#include "frontend/BinSource-macros.h" +#include "frontend/BinSourceRuntimeSupport.h" #include "frontend/BytecodeCompiler.h" // IsIdentifier #include "js/Result.h" @@ -40,34 +40,34 @@ const char COMPRESSION_IDENTITY[] = "identity;"; // single file. const uint32_t MAX_NUMBER_OF_STRINGS = 32768; -using AutoList = BinASTTokenReaderMultipart::AutoList; -using AutoTaggedTuple = BinASTTokenReaderMultipart::AutoTaggedTuple; +using AutoList = BinTokenReaderMultipart::AutoList; +using AutoTaggedTuple = BinTokenReaderMultipart::AutoTaggedTuple; using CharSlice = BinaryASTSupport::CharSlice; -using Chars = BinASTTokenReaderMultipart::Chars; +using Chars = BinTokenReaderMultipart::Chars; -BinASTTokenReaderMultipart::BinASTTokenReaderMultipart(JSContext* cx, - ErrorReporter* er, - const uint8_t* start, - const size_t length) - : BinASTTokenReaderBase(cx, er, start, length), +BinTokenReaderMultipart::BinTokenReaderMultipart(JSContext* cx, + ErrorReporter* er, + const uint8_t* start, + const size_t length) + : BinTokenReaderBase(cx, er, start, length), metadata_(nullptr), posBeforeTree_(nullptr) { MOZ_ASSERT(er); } -BinASTTokenReaderMultipart::~BinASTTokenReaderMultipart() { +BinTokenReaderMultipart::~BinTokenReaderMultipart() { if (metadata_ && metadataOwned_ == MetadataOwnership::Owned) { UniqueBinASTSourceMetadataPtr ptr(metadata_); } } -BinASTSourceMetadata* BinASTTokenReaderMultipart::takeMetadata() { +BinASTSourceMetadata* BinTokenReaderMultipart::takeMetadata() { MOZ_ASSERT(metadataOwned_ == MetadataOwnership::Owned); metadataOwned_ = MetadataOwnership::Unowned; return metadata_; } -JS::Result BinASTTokenReaderMultipart::initFromScriptSource( +JS::Result BinTokenReaderMultipart::initFromScriptSource( ScriptSource* scriptSource) { metadata_ = scriptSource->binASTSourceMetadata(); metadataOwned_ = MetadataOwnership::Unowned; @@ -75,7 +75,7 @@ JS::Result BinASTTokenReaderMultipart::initFromScriptSource( return Ok(); } -JS::Result BinASTTokenReaderMultipart::readHeader() { +JS::Result BinTokenReaderMultipart::readHeader() { // Check that we don't call this function twice. MOZ_ASSERT(!posBeforeTree_); @@ -103,13 +103,13 @@ JS::Result BinASTTokenReaderMultipart::readHeader() { } BINJS_MOZ_TRY_DECL(grammarNumberOfEntries, readInternalUint32()); - if (grammarNumberOfEntries > BINASTKIND_LIMIT) { // Sanity check. + if (grammarNumberOfEntries > BINKIND_LIMIT) { // Sanity check. return raiseError("Invalid number of entries in grammar table"); } - // This table maps BinASTKind index -> BinASTKind. + // This table maps BinKind index -> BinKind. // Initialize and populate. - Vector grammarTable_(cx_); + Vector grammarTable_(cx_); if (!grammarTable_.reserve(grammarNumberOfEntries)) { return raiseOOM(); } @@ -125,7 +125,7 @@ JS::Result BinASTTokenReaderMultipart::readHeader() { CharSlice name((const char*)current_, byteLen); current_ += byteLen; - BINJS_MOZ_TRY_DECL(kind, cx_->runtime()->binast().binASTKind(cx_, name)); + BINJS_MOZ_TRY_DECL(kind, cx_->runtime()->binast().binKind(cx_, name)); if (!kind) { return raiseError("Invalid entry in grammar table"); } @@ -215,13 +215,13 @@ JS::Result BinASTTokenReaderMultipart::readHeader() { return Ok(); } -void BinASTTokenReaderMultipart::traceMetadata(JSTracer* trc) { +void BinTokenReaderMultipart::traceMetadata(JSTracer* trc) { if (metadata_) { metadata_->trace(trc); } } -JS::Result BinASTTokenReaderMultipart::readBool() { +JS::Result BinTokenReaderMultipart::readBool() { updateLatestKnownGood(); BINJS_MOZ_TRY_DECL(byte, readByte()); @@ -241,7 +241,7 @@ JS::Result BinASTTokenReaderMultipart::readBool() { // // NULL_FLOAT_REPRESENTATION (signaling NaN) => null // anything other 64 bit sequence => IEEE-764 64-bit floating point number -JS::Result BinASTTokenReaderMultipart::readDouble() { +JS::Result BinTokenReaderMultipart::readDouble() { updateLatestKnownGood(); uint8_t bytes[8]; @@ -262,7 +262,7 @@ JS::Result BinASTTokenReaderMultipart::readDouble() { } // A single atom is represented as an index into the table of strings. -JS::Result BinASTTokenReaderMultipart::readMaybeAtom() { +JS::Result BinTokenReaderMultipart::readMaybeAtom() { updateLatestKnownGood(); BINJS_MOZ_TRY_DECL(index, readInternalUint32()); @@ -272,7 +272,7 @@ JS::Result BinASTTokenReaderMultipart::readMaybeAtom() { return metadata_->getAtom(index); } -JS::Result BinASTTokenReaderMultipart::readAtom() { +JS::Result BinTokenReaderMultipart::readAtom() { BINJS_MOZ_TRY_DECL(maybe, readMaybeAtom()); if (!maybe) { @@ -282,7 +282,7 @@ JS::Result BinASTTokenReaderMultipart::readAtom() { return maybe; } -JS::Result BinASTTokenReaderMultipart::readMaybeIdentifierName() { +JS::Result BinTokenReaderMultipart::readMaybeIdentifierName() { BINJS_MOZ_TRY_DECL(result, readMaybeAtom()); if (result) { if (!IsIdentifier(result)) { @@ -292,7 +292,7 @@ JS::Result BinASTTokenReaderMultipart::readMaybeIdentifierName() { return result; } -JS::Result BinASTTokenReaderMultipart::readIdentifierName() { +JS::Result BinTokenReaderMultipart::readIdentifierName() { BINJS_MOZ_TRY_DECL(result, readMaybeAtom()); if (!IsIdentifier(result)) { return raiseError("Invalid identifier"); @@ -300,15 +300,15 @@ JS::Result BinASTTokenReaderMultipart::readIdentifierName() { return result; } -JS::Result BinASTTokenReaderMultipart::readMaybePropertyKey() { +JS::Result BinTokenReaderMultipart::readMaybePropertyKey() { return readMaybeAtom(); } -JS::Result BinASTTokenReaderMultipart::readPropertyKey() { +JS::Result BinTokenReaderMultipart::readPropertyKey() { return readAtom(); } -JS::Result BinASTTokenReaderMultipart::readChars(Chars& out) { +JS::Result BinTokenReaderMultipart::readChars(Chars& out) { updateLatestKnownGood(); BINJS_MOZ_TRY_DECL(index, readInternalUint32()); @@ -320,7 +320,7 @@ JS::Result BinASTTokenReaderMultipart::readChars(Chars& out) { return Ok(); } -JS::Result BinASTTokenReaderMultipart::readVariant() { +JS::Result BinTokenReaderMultipart::readVariant() { updateLatestKnownGood(); BINJS_MOZ_TRY_DECL(index, readInternalUint32()); @@ -340,8 +340,7 @@ JS::Result BinASTTokenReaderMultipart::readVariant() { // ill-formed variant, so we don't run the risk of feching an ill-variant // more than once. Chars slice = metadata_->getSlice(index); // We have checked `index` above. - BINJS_MOZ_TRY_DECL(variant, - cx_->runtime()->binast().binASTVariant(cx_, slice)); + BINJS_MOZ_TRY_DECL(variant, cx_->runtime()->binast().binVariant(cx_, slice)); if (!variant) { return raiseError("Invalid string enum variant"); @@ -354,8 +353,8 @@ JS::Result BinASTTokenReaderMultipart::readVariant() { return *variant; } -JS::Result -BinASTTokenReaderMultipart::readSkippableSubTree() { +JS::Result +BinTokenReaderMultipart::readSkippableSubTree() { updateLatestKnownGood(); BINJS_MOZ_TRY_DECL(byteLen, readInternalUint32()); @@ -367,21 +366,20 @@ BinASTTokenReaderMultipart::readSkippableSubTree() { current_ += byteLen; - return BinASTTokenReaderBase::SkippableSubTree(start, byteLen); + return BinTokenReaderBase::SkippableSubTree(start, byteLen); } // Tagged tuples: // - uint32_t index in table [grammar]; // - content (specified by the higher-level grammar); -JS::Result BinASTTokenReaderMultipart::enterTaggedTuple( - BinASTKind& tag, BinASTTokenReaderMultipart::BinASTFields&, - AutoTaggedTuple& guard) { +JS::Result BinTokenReaderMultipart::enterTaggedTuple( + BinKind& tag, BinTokenReaderMultipart::BinFields&, AutoTaggedTuple& guard) { BINJS_MOZ_TRY_DECL(index, readInternalUint32()); - if (index >= metadata_->numBinASTKinds()) { + if (index >= metadata_->numBinKinds()) { return raiseError("Invalid index to grammar table"); } - tag = metadata_->getBinASTKind(index); + tag = metadata_->getBinKind(index); // Enter the body. guard.init(); @@ -395,8 +393,8 @@ JS::Result BinASTTokenReaderMultipart::enterTaggedTuple( // // The total byte length of `number of items` + `contents` must be `byte // length`. -JS::Result BinASTTokenReaderMultipart::enterList(uint32_t& items, - AutoList& guard) { +JS::Result BinTokenReaderMultipart::enterList(uint32_t& items, + AutoList& guard) { guard.init(); MOZ_TRY_VAR(items, readInternalUint32()); @@ -404,20 +402,19 @@ JS::Result BinASTTokenReaderMultipart::enterList(uint32_t& items, return Ok(); } -void BinASTTokenReaderMultipart::AutoBase::init() { initialized_ = true; } +void BinTokenReaderMultipart::AutoBase::init() { initialized_ = true; } -BinASTTokenReaderMultipart::AutoBase::AutoBase( - BinASTTokenReaderMultipart& reader) +BinTokenReaderMultipart::AutoBase::AutoBase(BinTokenReaderMultipart& reader) : initialized_(false), reader_(reader) {} -BinASTTokenReaderMultipart::AutoBase::~AutoBase() { +BinTokenReaderMultipart::AutoBase::~AutoBase() { // By now, the `AutoBase` must have been deinitialized by calling `done()`. // The only case in which we can accept not calling `done()` is if we have // bailed out because of an error. MOZ_ASSERT_IF(initialized_, reader_.hasRaisedError()); } -JS::Result BinASTTokenReaderMultipart::AutoBase::checkPosition( +JS::Result BinTokenReaderMultipart::AutoBase::checkPosition( const uint8_t* expectedEnd) { if (reader_.current_ != expectedEnd) { return reader_.raiseError( @@ -427,13 +424,12 @@ JS::Result BinASTTokenReaderMultipart::AutoBase::checkPosition( return Ok(); } -BinASTTokenReaderMultipart::AutoList::AutoList( - BinASTTokenReaderMultipart& reader) +BinTokenReaderMultipart::AutoList::AutoList(BinTokenReaderMultipart& reader) : AutoBase(reader) {} -void BinASTTokenReaderMultipart::AutoList::init() { AutoBase::init(); } +void BinTokenReaderMultipart::AutoList::init() { AutoBase::init(); } -JS::Result BinASTTokenReaderMultipart::AutoList::done() { +JS::Result BinTokenReaderMultipart::AutoList::done() { MOZ_ASSERT(initialized_); initialized_ = false; if (reader_.hasRaisedError()) { @@ -449,7 +445,7 @@ JS::Result BinASTTokenReaderMultipart::AutoList::done() { // Encoded as variable length number. MOZ_MUST_USE JS::Result -BinASTTokenReaderMultipart::readInternalUint32() { +BinTokenReaderMultipart::readInternalUint32() { uint32_t result = 0; uint32_t shift = 0; while (true) { @@ -475,11 +471,11 @@ BinASTTokenReaderMultipart::readInternalUint32() { } } -BinASTTokenReaderMultipart::AutoTaggedTuple::AutoTaggedTuple( - BinASTTokenReaderMultipart& reader) +BinTokenReaderMultipart::AutoTaggedTuple::AutoTaggedTuple( + BinTokenReaderMultipart& reader) : AutoBase(reader) {} -JS::Result BinASTTokenReaderMultipart::AutoTaggedTuple::done() { +JS::Result BinTokenReaderMultipart::AutoTaggedTuple::done() { MOZ_ASSERT(initialized_); initialized_ = false; if (reader_.hasRaisedError()) { diff --git a/js/src/frontend/BinASTTokenReaderMultipart.h b/js/src/frontend/BinTokenReaderMultipart.h similarity index 78% rename from js/src/frontend/BinASTTokenReaderMultipart.h rename to js/src/frontend/BinTokenReaderMultipart.h index 7195b05bf483..da3c67d1f97f 100644 --- a/js/src/frontend/BinASTTokenReaderMultipart.h +++ b/js/src/frontend/BinTokenReaderMultipart.h @@ -4,14 +4,14 @@ * 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/. */ -#ifndef frontend_BinASTTokenReaderMultipart_h -#define frontend_BinASTTokenReaderMultipart_h +#ifndef frontend_BinTokenReaderMultipart_h +#define frontend_BinTokenReaderMultipart_h #include "mozilla/Maybe.h" -#include "frontend/BinASTRuntimeSupport.h" -#include "frontend/BinASTToken.h" -#include "frontend/BinASTTokenReaderBase.h" +#include "frontend/BinSourceRuntimeSupport.h" +#include "frontend/BinToken.h" +#include "frontend/BinTokenReaderBase.h" #include "js/Result.h" @@ -30,19 +30,18 @@ namespace frontend { * - the reader does not support error recovery; * - the reader does not support lookahead or pushback. */ -class MOZ_STACK_CLASS BinASTTokenReaderMultipart - : public BinASTTokenReaderBase { +class MOZ_STACK_CLASS BinTokenReaderMultipart : public BinTokenReaderBase { public: class AutoList; class AutoTaggedTuple; using CharSlice = BinaryASTSupport::CharSlice; - // This implementation of `BinASTFields` is effectively `void`, as the format + // This implementation of `BinFields` is effectively `void`, as the format // does not embed field information. - class BinASTFields { + class BinFields { public: - explicit BinASTFields(JSContext*) {} + explicit BinFields(JSContext*) {} }; using Chars = CharSlice; @@ -52,18 +51,18 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart * * Does NOT copy the buffer. */ - BinASTTokenReaderMultipart(JSContext* cx, ErrorReporter* er, - const uint8_t* start, const size_t length); + BinTokenReaderMultipart(JSContext* cx, ErrorReporter* er, + const uint8_t* start, const size_t length); /** * Construct a token reader. * * Does NOT copy the buffer. */ - BinASTTokenReaderMultipart(JSContext* cx, ErrorReporter* er, - const Vector& chars); + BinTokenReaderMultipart(JSContext* cx, ErrorReporter* er, + const Vector& chars); - ~BinASTTokenReaderMultipart(); + ~BinTokenReaderMultipart(); /** * Read the header of the file. @@ -118,10 +117,10 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart MOZ_MUST_USE JS::Result readChars(Chars&); /** - * Read a single `BinASTVariant | null` value. + * Read a single `BinVariant | null` value. */ - MOZ_MUST_USE JS::Result> readMaybeVariant(); - MOZ_MUST_USE JS::Result readVariant(); + MOZ_MUST_USE JS::Result> readMaybeVariant(); + MOZ_MUST_USE JS::Result readVariant(); /** * Read over a single `[Skippable]` subtree value. @@ -171,7 +170,7 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart * @return out If the header of the tuple is invalid. */ MOZ_MUST_USE JS::Result enterTaggedTuple( - BinASTKind& tag, BinASTTokenReaderMultipart::BinASTFields& fields, + BinKind& tag, BinTokenReaderMultipart::BinFields& fields, AutoTaggedTuple& guard); /** @@ -188,10 +187,9 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart MOZ_MUST_USE JS::Result readInternalUint32(); private: - // A mapping string index => BinASTVariant as extracted from the [STRINGS] + // A mapping string index => BinVariant as extracted from the [STRINGS] // section of the file. Populated lazily. - js::HashMap, - SystemAllocPolicy> + js::HashMap, SystemAllocPolicy> variantsTable_; enum class MetadataOwnership { Owned, Unowned }; @@ -200,9 +198,9 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart const uint8_t* posBeforeTree_; - BinASTTokenReaderMultipart(const BinASTTokenReaderMultipart&) = delete; - BinASTTokenReaderMultipart(BinASTTokenReaderMultipart&&) = delete; - BinASTTokenReaderMultipart& operator=(BinASTTokenReaderMultipart&) = delete; + BinTokenReaderMultipart(const BinTokenReaderMultipart&) = delete; + BinTokenReaderMultipart(BinTokenReaderMultipart&&) = delete; + BinTokenReaderMultipart& operator=(BinTokenReaderMultipart&) = delete; public: void traceMetadata(JSTracer* trc); @@ -226,38 +224,38 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart // Base class used by other Auto* classes. class MOZ_STACK_CLASS AutoBase { protected: - explicit AutoBase(BinASTTokenReaderMultipart& reader); + explicit AutoBase(BinTokenReaderMultipart& reader); ~AutoBase(); // Raise an error if we are not in the expected position. MOZ_MUST_USE JS::Result checkPosition(const uint8_t* expectedPosition); - friend BinASTTokenReaderMultipart; + friend BinTokenReaderMultipart; void init(); // Set to `true` if `init()` has been called. Reset to `false` once // all conditions have been checked. bool initialized_; - BinASTTokenReaderMultipart& reader_; + BinTokenReaderMultipart& reader_; }; // Guard class used to ensure that `enterList` is used properly. class MOZ_STACK_CLASS AutoList : public AutoBase { public: - explicit AutoList(BinASTTokenReaderMultipart& reader); + explicit AutoList(BinTokenReaderMultipart& reader); // Check that we have properly read to the end of the list. MOZ_MUST_USE JS::Result done(); protected: - friend BinASTTokenReaderMultipart; + friend BinTokenReaderMultipart; void init(); }; // Guard class used to ensure that `enterTaggedTuple` is used properly. class MOZ_STACK_CLASS AutoTaggedTuple : public AutoBase { public: - explicit AutoTaggedTuple(BinASTTokenReaderMultipart& reader); + explicit AutoTaggedTuple(BinTokenReaderMultipart& reader); // Check that we have properly read to the end of the tuple. MOZ_MUST_USE JS::Result done(); @@ -280,15 +278,15 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart } template - static JS::Result checkFields( - const BinASTKind kind, const BinASTFields& actual, - const BinASTField (&expected)[N]) { + static JS::Result checkFields(const BinKind kind, + const BinFields& actual, + const BinField (&expected)[N]) { // Not implemented in this tokenizer. return Ok(); } - static JS::Result checkFields0(const BinASTKind kind, - const BinASTFields& actual) { + static JS::Result checkFields0(const BinKind kind, + const BinFields& actual) { // Not implemented in this tokenizer. return Ok(); } @@ -297,4 +295,4 @@ class MOZ_STACK_CLASS BinASTTokenReaderMultipart } // namespace frontend } // namespace js -#endif // frontend_BinASTTokenReaderMultipart_h +#endif // frontend_BinTokenReaderMultipart_h diff --git a/js/src/frontend/BytecodeCompiler.cpp b/js/src/frontend/BytecodeCompiler.cpp index 682c26f1545b..cb7e54b8aac8 100644 --- a/js/src/frontend/BytecodeCompiler.cpp +++ b/js/src/frontend/BytecodeCompiler.cpp @@ -766,8 +766,8 @@ JSScript* frontend::CompileGlobalBinASTScript( GlobalSharedContext globalsc(cx, ScopeKind::Global, directives, options.extraWarningsOption); - frontend::BinASTParser parser( - cx, alloc, usedNames, options, sourceObj); + frontend::BinASTParser parser(cx, alloc, usedNames, + options, sourceObj); // Metadata stores internal pointers, so we must use the same buffer every // time, including for lazy parses @@ -1057,7 +1057,7 @@ bool frontend::CompileLazyBinASTFunction(JSContext* cx, script->setHasBeenCloned(); } - frontend::BinASTParser parser( + frontend::BinASTParser parser( cx, cx->tempLifoAlloc(), usedNames, options, sourceObj, lazy); auto parsed = diff --git a/js/src/frontend/BytecodeCompiler.h b/js/src/frontend/BytecodeCompiler.h index 7eaa266b9ae7..b19948a53eb0 100644 --- a/js/src/frontend/BytecodeCompiler.h +++ b/js/src/frontend/BytecodeCompiler.h @@ -60,7 +60,7 @@ * ParseContext.h: class ParseContext: Extremely complex class that serves a lot * of purposes, but it's a single class - essentially no derived classes - so * it's a little easier to comprehend all at once. (SourceParseContext and - * BinASTParseContext do derive from ParseContext, but they do nothing except + * BinParseContext do derive from ParseContext, but they do nothing except * adjust the constructor's arguments). * Note it uses a thing called Nestable, which implements a stack of objects: * you can push (and pop) instances to a stack (linked list) as you parse diff --git a/js/src/frontend/binast/README.md b/js/src/frontend/binast/README.md deleted file mode 100644 index 739c0d44bd8d..000000000000 --- a/js/src/frontend/binast/README.md +++ /dev/null @@ -1,16 +0,0 @@ -A parser generator used to generate the following files: - -- js/src/frontend/BinASTParser.h -- js/src/frontend/BinASTParser.cpp -- js/src/frontent/BinASTToken.h - -from the following files: - -- js/src/frontend/BinAST.webidl_ (specifications of BinAST) -- js/src/frontend/BinAST.yaml (parser generator driver) - -To use it: -```sh -$ cd $(topsrcdir)/js/src/frontend/binast -% ./build.sh -``` diff --git a/js/src/frontend/binast/Cargo.toml b/js/src/frontend/binsource/Cargo.toml similarity index 93% rename from js/src/frontend/binast/Cargo.toml rename to js/src/frontend/binsource/Cargo.toml index ae46d12ca9a0..9b2b0ba51c42 100644 --- a/js/src/frontend/binast/Cargo.toml +++ b/js/src/frontend/binsource/Cargo.toml @@ -14,5 +14,5 @@ yaml-rust = "^0.4.2" webidl = "^0.8" [[bin]] -name = "binast" +name = "binsource" path = "src/main.rs" diff --git a/js/src/frontend/binsource/README.md b/js/src/frontend/binsource/README.md new file mode 100644 index 000000000000..d4c86d10b285 --- /dev/null +++ b/js/src/frontend/binsource/README.md @@ -0,0 +1,16 @@ +A parser generator used to generate the following files: + +- js/src/frontend/BinSource-auto.h +- js/src/frontend/BinSource-auto.cpp +- js/src/frontent/BinToken.h + +from the following files: + +- js/src/frontend/BinSource.webidl_ (specifications of BinAST) +- js/src/frontend/BinSource.yaml (parser generator driver) + +To use it: +```sh +$ cd $(topsrcdir)/js/src/frontend/binsource +% ./build.sh +``` diff --git a/js/src/frontend/binast/build.sh b/js/src/frontend/binsource/build.sh similarity index 83% rename from js/src/frontend/binast/build.sh rename to js/src/frontend/binsource/build.sh index 6acb70d78505..bb6f57b342cf 100755 --- a/js/src/frontend/binast/build.sh +++ b/js/src/frontend/binsource/build.sh @@ -1,12 +1,12 @@ #!/bin/sh cargo run -- \ - ../BinAST.webidl_ \ - ../BinAST.yaml \ + ../BinSource.webidl_ \ + ../BinSource.yaml \ --out-class ../BinASTParser-tmp.h \ --out-impl ../BinASTParser-tmp.cpp \ --out-enum ../BinASTEnum-tmp.h \ - --out-token ../BinASTToken-tmp.h + --out-token ../BinToken-tmp.h MACH=../../../../mach @@ -14,7 +14,7 @@ ${MACH} clang-format --path \ ../BinASTParser-tmp.h \ ../BinASTParser-tmp.cpp \ ../BinASTEnum-tmp.h \ - ../BinASTToken-tmp.h + ../BinToken-tmp.h # Usage: update SRC DST # @@ -36,4 +36,4 @@ update() { update ../BinASTParser-tmp.h ../BinASTParser.h update ../BinASTParser-tmp.cpp ../BinASTParser.cpp update ../BinASTEnum-tmp.h ../BinASTEnum.h -update ../BinASTToken-tmp.h ../BinASTToken.h +update ../BinToken-tmp.h ../BinToken.h diff --git a/js/src/frontend/binast/moz.build b/js/src/frontend/binsource/moz.build similarity index 88% rename from js/src/frontend/binast/moz.build rename to js/src/frontend/binsource/moz.build index a3e8a14877ed..ab07b96d07f9 100644 --- a/js/src/frontend/binast/moz.build +++ b/js/src/frontend/binsource/moz.build @@ -4,4 +4,4 @@ # 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/. -HOST_RUST_PROGRAMS += ['binast'] +HOST_RUST_PROGRAMS += ['binsource'] diff --git a/js/src/frontend/binast/src/main.rs b/js/src/frontend/binsource/src/main.rs similarity index 98% rename from js/src/frontend/binast/src/main.rs rename to js/src/frontend/binsource/src/main.rs index 365b16bf185a..9d7151d53a93 100644 --- a/js/src/frontend/binast/src/main.rs +++ b/js/src/frontend/binsource/src/main.rs @@ -162,13 +162,13 @@ struct GlobalRules { /// defining the tokens. hpp_tokens_footer: Option, - /// Documentation for the `BinASTKind` class enum. + /// Documentation for the `BinKind` class enum. hpp_tokens_kind_doc: Option, - /// Documentation for the `BinASTField` class enum. + /// Documentation for the `BinField` class enum. hpp_tokens_field_doc: Option, - /// Documentation for the `BinASTVariant` class enum. + /// Documentation for the `BinVariant` class enum. hpp_tokens_variants_doc: Option, /// Per-node rules. @@ -532,7 +532,7 @@ enum MethodCallKind { /// Fixed parameter of interface method. const INTERFACE_PARAMS: &str = - "const size_t start, const BinASTKind kind, const BinASTFields& fields"; + "const size_t start, const BinKind kind, const BinFields& fields"; /// Fixed arguments of interface method. const INTERFACE_ARGS: &str = @@ -560,7 +560,7 @@ struct CPPExporter { option_parsers_to_generate: Vec, /// A mapping from symbol (e.g. `+`, `-`, `instanceof`, ...) to the - /// name of the symbol as part of `enum class BinASTVariant` + /// name of the symbol as part of `enum class BinVariant` /// (e.g. `UnaryOperatorDelete`). variants_by_symbol: HashMap, @@ -601,7 +601,7 @@ impl CPPExporter { list_parsers_to_generate.sort_by(|a, b| str::cmp(a.name.to_str(), b.name.to_str())); option_parsers_to_generate.sort_by(|a, b| str::cmp(a.name.to_str(), b.name.to_str())); - // Prepare variant_by_symbol, which will let us lookup the BinASTVariant name of + // Prepare variant_by_symbol, which will let us lookup the BinVariant name of // a symbol. Since some symbols can appear in several enums (e.g. "+" // is both a unary and a binary operator), we need to collect all the // string enums that contain each symbol and come up with a unique name @@ -944,14 +944,14 @@ impl CPPExporter { spec_name = name)) .format(" \\\n"))); buffer.push_str(" -enum class BinASTKind { +enum class BinKind { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_KIND(EMIT_ENUM) #undef EMIT_ENUM }; "); - buffer.push_str(&format!("\n// The number of distinct values of BinASTKind.\nconst size_t BINASTKIND_LIMIT = {};\n\n\n", kind_limit)); + buffer.push_str(&format!("\n// The number of distinct values of BinKind.\nconst size_t BINKIND_LIMIT = {};\n\n\n", kind_limit)); buffer.push_str("\n\n"); if self.rules.hpp_tokens_field_doc.is_some() { buffer.push_str(&self.rules.hpp_tokens_field_doc.reindent("")); @@ -968,13 +968,13 @@ enum class BinASTKind { enum_name = name.to_cpp_enum_case())) .format(" \\\n"))); buffer.push_str(" -enum class BinASTField { +enum class BinField { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_FIELD(EMIT_ENUM) #undef EMIT_ENUM }; "); - buffer.push_str(&format!("\n// The number of distinct values of BinASTField.\nconst size_t BINASTFIELD_LIMIT = {};\n\n\n", field_limit)); + buffer.push_str(&format!("\n// The number of distinct values of BinField.\nconst size_t BINFIELD_LIMIT = {};\n\n\n", field_limit)); if self.rules.hpp_tokens_variants_doc.is_some() { buffer.push_str(&self.rules.hpp_tokens_variants_doc.reindent("")); @@ -995,13 +995,13 @@ enum class BinASTField { .format(" \\\n"))); buffer.push_str(" -enum class BinASTVariant { +enum class BinVariant { #define EMIT_ENUM(name, _) name, FOR_EACH_BIN_VARIANT(EMIT_ENUM) #undef EMIT_ENUM }; "); - buffer.push_str(&format!("\n// The number of distinct values of BinASTVariant.\nconst size_t BINASTVARIANT_LIMIT = {};\n\n\n", + buffer.push_str(&format!("\n// The number of distinct values of BinVariant.\nconst size_t BINVARIANT_LIMIT = {};\n\n\n", variants_limit)); buffer.push_str(&self.rules.hpp_tokens_footer.reindent("")); @@ -1243,8 +1243,8 @@ impl CPPExporter { buffer.push_str(&format!("{bnf} {first_line} {{ - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); const auto start = tokenizer_->offset(); @@ -1280,14 +1280,14 @@ impl CPPExporter { if rule_for_this_arm.disabled { buffer_cases.push_str(&format!(" - case BinASTKind::{variant_name}: + case BinKind::{variant_name}: return raiseError(\"FIXME: Not implemented yet in this preview release ({variant_name})\");", variant_name = node.to_cpp_enum_case())); continue; } buffer_cases.push_str(&format!(" - case BinASTKind::{variant_name}: + case BinKind::{variant_name}: {call} {arm_after} break;", call = self.get_method_call("result", node, @@ -1458,15 +1458,15 @@ impl CPPExporter { NamedType::Interface(_) => { buffer.push_str(&format!("{first_line} {{ - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); {type_ok} result; - if (kind == BinASTKind::{null}) {{ + if (kind == BinKind::{null}) {{ {none_block} - }} else if (kind == BinASTKind::{kind}) {{ + }} else if (kind == BinKind::{kind}) {{ const auto start = tokenizer_->offset(); {before}{call}{after} }} else {{ @@ -1511,13 +1511,13 @@ impl CPPExporter { &TypeSpec::TypeSum(_) => { buffer.push_str(&format!("{first_line} {{ - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); {type_ok} result; - if (kind == BinASTKind::{null}) {{ + if (kind == BinKind::{null}) {{ {none_block} }} else {{ const auto start = tokenizer_->offset(); @@ -1673,12 +1673,12 @@ impl CPPExporter { // Generate public method buffer.push_str(&format!("{first_line} {{ - BinASTKind kind; - BinASTFields fields(cx_); + BinKind kind; + BinFields fields(cx_); AutoTaggedTuple guard(*tokenizer_); MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard)); - if (kind != BinASTKind::{kind}) {{ + if (kind != BinKind::{kind}) {{ return raiseInvalidKind(\"{kind}\", kind); }} const auto start = tokenizer_->offset(); @@ -1714,7 +1714,7 @@ impl CPPExporter { let fields_type_list = format!("{{ {} }}", interface.contents() .fields() .iter() - .map(|field| format!("BinASTField::{}", field.name().to_cpp_enum_case())) + .map(|field| format!("BinField::{}", field.name().to_cpp_enum_case())) .format(", ")); let mut fields_implem = String::new(); @@ -1755,7 +1755,7 @@ impl CPPExporter { } Some(IsNullable { is_nullable: false, content: Primitive::Offset }) => { if needs_block { - (Some(format!("BinASTTokenReaderBase::SkippableSubTree {var_name};", var_name = var_name)), + (Some(format!("BinTokenReaderBase::SkippableSubTree {var_name};", var_name = var_name)), Some(format!("MOZ_TRY_VAR({var_name}, tokenizer_->readSkippableSubTree());", var_name = var_name))) } else { (None, @@ -1881,7 +1881,7 @@ impl CPPExporter { // The following strategy is designed for old versions of clang. format!(" #if defined(DEBUG) - const BinASTField expected_fields[{number_of_fields}] = {fields_type_list}; + const BinField expected_fields[{number_of_fields}] = {fields_type_list}; MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields)); #endif // defined(DEBUG)", fields_type_list = fields_type_list, @@ -1889,7 +1889,7 @@ impl CPPExporter { }; buffer.push_str(&format!("{first_line} {{ - MOZ_ASSERT(kind == BinASTKind::{kind}); + MOZ_ASSERT(kind == BinKind::{kind}); BINJS_TRY(CheckRecursionLimit(cx_)); {check_fields} {pre}{fields_implem} @@ -1960,11 +1960,11 @@ impl CPPExporter { cases = enum_.strings() .iter() .map(|symbol| { - format!(" case BinASTVariant::{binastvariant_variant}: + format!(" case BinVariant::{binvariant_variant}: return {kind}::{specialized_variant};", kind = kind, specialized_variant = symbol.to_cpp_enum_case(), - binastvariant_variant = self.variants_by_symbol.get(symbol) + binvariant_variant = self.variants_by_symbol.get(symbol) .unwrap() ) }) diff --git a/js/src/frontend/binast/src/refgraph.rs b/js/src/frontend/binsource/src/refgraph.rs similarity index 100% rename from js/src/frontend/binast/src/refgraph.rs rename to js/src/frontend/binsource/src/refgraph.rs diff --git a/js/src/frontend/moz.build b/js/src/frontend/moz.build index 8730697212db..0f5168c3eb9b 100644 --- a/js/src/frontend/moz.build +++ b/js/src/frontend/moz.build @@ -72,14 +72,14 @@ if CONFIG['JS_BUILD_BINAST']: 'BinASTParser.cpp', 'BinASTParserBase.cpp', 'BinASTParserPerTokenizer.cpp', - 'BinASTRuntimeSupport.cpp', - 'BinASTToken.cpp', - 'BinASTTokenReaderBase.cpp', - 'BinASTTokenReaderMultipart.cpp', + 'BinSourceRuntimeSupport.cpp', + 'BinToken.cpp', + 'BinTokenReaderBase.cpp', + 'BinTokenReaderMultipart.cpp', ] DIRS += [ - 'binast' + 'binsource' ] # Instrument BinAST files for fuzzing as we have a fuzzing target for BinAST. @@ -89,6 +89,6 @@ if CONFIG['JS_BUILD_BINAST']: SOURCES['BinASTParser.cpp'].flags += libfuzzer_flags SOURCES['BinASTParserBase.cpp'].flags += libfuzzer_flags SOURCES['BinASTParserPerTokenizer.cpp'].flags += libfuzzer_flags - SOURCES['BinASTToken.cpp'].flags += libfuzzer_flags - SOURCES['BinASTTokenReaderBase.cpp'].flags += libfuzzer_flags - SOURCES['BinASTTokenReaderMultipart.cpp'].flags += libfuzzer_flags + SOURCES['BinToken.cpp'].flags += libfuzzer_flags + SOURCES['BinTokenReaderBase.cpp'].flags += libfuzzer_flags + SOURCES['BinTokenReaderMultipart.cpp'].flags += libfuzzer_flags diff --git a/js/src/jsapi-tests/testBinASTReader.cpp b/js/src/jsapi-tests/testBinASTReader.cpp index a9a4f51e0eb3..ae336f786414 100644 --- a/js/src/jsapi-tests/testBinASTReader.cpp +++ b/js/src/jsapi-tests/testBinASTReader.cpp @@ -459,10 +459,10 @@ void runTestFromPath(JSContext* cx, const char* path) { BEGIN_TEST(testBinASTReaderMultipartECMAScript2) { #if defined(XP_WIN) - runTestFromPath( + runTestFromPath( cx, "jsapi-tests\\binast\\parser\\multipart\\"); #else - runTestFromPath( + runTestFromPath( cx, "jsapi-tests/binast/parser/multipart/"); #endif // defined(XP_XIN) return true; diff --git a/js/src/shell/js.cpp b/js/src/shell/js.cpp index 5ec996197f7e..d154846a207d 100644 --- a/js/src/shell/js.cpp +++ b/js/src/shell/js.cpp @@ -85,7 +85,7 @@ #include "jit/JitRealm.h" #include "jit/shared/CodeGenerator-shared.h" #include "js/ArrayBuffer.h" // JS::{CreateMappedArrayBufferContents,NewMappedArrayBufferWithContents,IsArrayBufferObject,GetArrayBufferLengthAndData} -#include "js/BuildId.h" // JS::BuildIdCharVector, JS::SetProcessBuildIdOp +#include "js/BuildId.h" // JS::BuildIdCharVector, JS::SetProcessBuildIdOp #include "js/CharacterEncoding.h" #include "js/CompilationAndEvaluation.h" #include "js/CompileOptions.h" @@ -5109,7 +5109,7 @@ static bool BinParse(JSContext* cx, unsigned argc, Value* vp) { Directives directives(false); GlobalSharedContext globalsc(cx, ScopeKind::Global, directives, false); - auto parseFunc = ParseBinASTData; + auto parseFunc = ParseBinASTData; if (!parseFunc(cx, buf_data, buf_length, &globalsc, usedNames, options, sourceObj)) { return false; @@ -10889,8 +10889,7 @@ int main(int argc, char** argv, char** envp) { "Forcibly activate tiering and block " "instantiation on completion of tier2") #ifdef ENABLE_WASM_GC - || - !op.addBoolOption('\0', "wasm-gc", "Enable experimental wasm GC features") + || !op.addBoolOption('\0', "wasm-gc", "Enable experimental wasm GC features") #else || !op.addBoolOption('\0', "wasm-gc", "No-op") #endif diff --git a/js/src/vm/JSScript.cpp b/js/src/vm/JSScript.cpp index decf6378e68d..b0acc916b1a2 100644 --- a/js/src/vm/JSScript.cpp +++ b/js/src/vm/JSScript.cpp @@ -2631,32 +2631,31 @@ XDRResult ScriptSource::XDR(XDRState* xdr, #if defined(JS_BUILD_BINAST) UniquePtr& binASTMetadata = ss->binASTMetadata_; - uint32_t numBinASTKinds; + uint32_t numBinKinds; uint32_t numStrings; if (mode == XDR_ENCODE) { - numBinASTKinds = binASTMetadata->numBinASTKinds(); + numBinKinds = binASTMetadata->numBinKinds(); numStrings = binASTMetadata->numStrings(); } - MOZ_TRY(xdr->codeUint32(&numBinASTKinds)); + MOZ_TRY(xdr->codeUint32(&numBinKinds)); MOZ_TRY(xdr->codeUint32(&numStrings)); if (mode == XDR_DECODE) { // Use calloc, since we're storing this immediately, and filling it // might GC, to avoid marking bogus atoms. auto metadata = static_cast( - js_calloc(frontend::BinASTSourceMetadata::totalSize(numBinASTKinds, + js_calloc(frontend::BinASTSourceMetadata::totalSize(numBinKinds, numStrings))); if (!metadata) { return xdr->fail(JS::TranscodeResult_Throw); } - new (metadata) - frontend::BinASTSourceMetadata(numBinASTKinds, numStrings); + new (metadata) frontend::BinASTSourceMetadata(numBinKinds, numStrings); ss->setBinASTSourceMetadata(metadata); } - for (uint32_t i = 0; i < numBinASTKinds; i++) { - frontend::BinASTKind* binASTKindBase = binASTMetadata->binASTKindBase(); - MOZ_TRY(xdr->codeEnum32(&binASTKindBase[i])); + for (uint32_t i = 0; i < numBinKinds; i++) { + frontend::BinKind* binKindBase = binASTMetadata->binKindBase(); + MOZ_TRY(xdr->codeEnum32(&binKindBase[i])); } RootedAtom atom(xdr->cx()); diff --git a/js/src/vm/JSScript.h b/js/src/vm/JSScript.h index 1b3affed2a97..ba693282d432 100644 --- a/js/src/vm/JSScript.h +++ b/js/src/vm/JSScript.h @@ -25,7 +25,7 @@ #include "jstypes.h" -#include "frontend/BinASTRuntimeSupport.h" +#include "frontend/BinSourceRuntimeSupport.h" #include "frontend/NameAnalysisTypes.h" #include "gc/Barrier.h" #include "gc/Rooting.h" diff --git a/js/src/vm/Runtime.h b/js/src/vm/Runtime.h index cc4e3f75f853..9d19803d2d76 100644 --- a/js/src/vm/Runtime.h +++ b/js/src/vm/Runtime.h @@ -24,7 +24,7 @@ #include "builtin/AtomicsObject.h" #include "builtin/intl/SharedIntlData.h" #include "builtin/Promise.h" -#include "frontend/BinASTRuntimeSupport.h" +#include "frontend/BinSourceRuntimeSupport.h" #include "frontend/NameCollections.h" #include "gc/GCRuntime.h" #include "gc/Tracer.h"