--- a/js/src/frontend/BinSource-auto.cpp
+++ b/js/src/frontend/BinSource-auto.cpp
@@ -60,24 +60,22 @@ BinASTParser<Tok>::parseArrowExpression(
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumArrowExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ArrowExpression", kind);
}
return result;
}
/*
@@ -102,36 +100,31 @@ BinASTParser<Tok>::parseAssignmentTarget
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
-
break;
case BinKind::AssignmentTargetIdentifier:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
-
break;
case BinKind::ComputedMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
-
break;
case BinKind::ObjectAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
-
break;
case BinKind::StaticMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
-
break;
default:
return raiseInvalidKind("AssignmentTarget", kind);
}
return result;
}
/*
@@ -157,40 +150,34 @@ BinASTParser<Tok>::parseAssignmentTarget
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
-
break;
case BinKind::AssignmentTargetIdentifier:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
-
break;
case BinKind::AssignmentTargetWithInitializer:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetWithInitializer(start, kind, fields));
-
break;
case BinKind::ComputedMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
-
break;
case BinKind::ObjectAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
-
break;
case BinKind::StaticMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
-
break;
default:
return raiseInvalidKind("AssignmentTargetOrAssignmentTargetWithInitializer", kind);
}
return result;
}
/*
@@ -212,24 +199,22 @@ BinASTParser<Tok>::parseAssignmentTarget
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
-
break;
case BinKind::ObjectAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
-
break;
default:
return raiseInvalidKind("AssignmentTargetPattern", kind);
}
return result;
}
/*
@@ -251,24 +236,22 @@ BinASTParser<Tok>::parseAssignmentTarget
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::AssignmentTargetPropertyIdentifier:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetPropertyIdentifier(start, kind, fields));
-
break;
case BinKind::AssignmentTargetPropertyProperty:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetPropertyProperty(start, kind, fields));
-
break;
default:
return raiseInvalidKind("AssignmentTargetProperty", kind);
}
return result;
}
/*
@@ -291,28 +274,25 @@ BinASTParser<Tok>::parseBinding()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayBinding:
MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields));
-
break;
case BinKind::BindingIdentifier:
MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields));
-
break;
case BinKind::ObjectBinding:
MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Binding", kind);
}
return result;
}
/*
@@ -336,32 +316,28 @@ BinASTParser<Tok>::parseBindingOrBinding
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayBinding:
MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields));
-
break;
case BinKind::BindingIdentifier:
MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields));
-
break;
case BinKind::BindingWithInitializer:
MOZ_TRY_VAR(result, parseInterfaceBindingWithInitializer(start, kind, fields));
-
break;
case BinKind::ObjectBinding:
MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields));
-
break;
default:
return raiseInvalidKind("BindingOrBindingWithInitializer", kind);
}
return result;
}
/*
@@ -383,24 +359,22 @@ BinASTParser<Tok>::parseBindingPattern()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayBinding:
MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields));
-
break;
case BinKind::ObjectBinding:
MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields));
-
break;
default:
return raiseInvalidKind("BindingPattern", kind);
}
return result;
}
/*
@@ -422,24 +396,22 @@ BinASTParser<Tok>::parseBindingProperty(
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::BindingPropertyIdentifier:
MOZ_TRY_VAR(result, parseInterfaceBindingPropertyIdentifier(start, kind, fields));
-
break;
case BinKind::BindingPropertyProperty:
MOZ_TRY_VAR(result, parseInterfaceBindingPropertyProperty(start, kind, fields));
-
break;
default:
return raiseInvalidKind("BindingProperty", kind);
}
return result;
}
/*
@@ -464,36 +436,31 @@ BinASTParser<Tok>::parseExportDeclaratio
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::Export:
MOZ_TRY_VAR(result, parseInterfaceExport(start, kind, fields));
-
break;
case BinKind::ExportAllFrom:
MOZ_TRY_VAR(result, parseInterfaceExportAllFrom(start, kind, fields));
-
break;
case BinKind::ExportDefault:
MOZ_TRY_VAR(result, parseInterfaceExportDefault(start, kind, fields));
-
break;
case BinKind::ExportFrom:
MOZ_TRY_VAR(result, parseInterfaceExportFrom(start, kind, fields));
-
break;
case BinKind::ExportLocals:
MOZ_TRY_VAR(result, parseInterfaceExportLocals(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ExportDeclaration", kind);
}
return result;
}
/*
@@ -543,136 +510,106 @@ BinASTParser<Tok>::parseExpression()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Expression", kind);
}
return result;
}
/*
@@ -723,140 +660,109 @@ BinASTParser<Tok>::parseExpressionOrSupe
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::Super:
MOZ_TRY_VAR(result, parseInterfaceSuper(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ExpressionOrSuper", kind);
}
return result;
}
/*
@@ -907,140 +813,109 @@ BinASTParser<Tok>::parseExpressionOrTemp
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateElement:
MOZ_TRY_VAR(result, parseInterfaceTemplateElement(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ExpressionOrTemplateElement", kind);
}
return result;
}
/*
@@ -1066,40 +941,34 @@ BinASTParser<Tok>::parseForInOfBindingOr
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
-
break;
case BinKind::AssignmentTargetIdentifier:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
-
break;
case BinKind::ComputedMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
-
break;
case BinKind::ForInOfBinding:
MOZ_TRY_VAR(result, parseInterfaceForInOfBinding(start, kind, fields));
-
break;
case BinKind::ObjectAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
-
break;
case BinKind::StaticMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ForInOfBindingOrAssignmentTarget", kind);
}
return result;
}
/*
@@ -1150,140 +1019,109 @@ BinASTParser<Tok>::parseFunctionBodyOrEx
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::FunctionBody:
MOZ_TRY_VAR(result, parseInterfaceFunctionBody(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("FunctionBodyOrExpression", kind);
}
return result;
}
/*
@@ -1305,24 +1143,22 @@ BinASTParser<Tok>::parseFunctionDeclarat
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::SkippableFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
-
break;
default:
return raiseInvalidKind("FunctionDeclaration", kind);
}
return result;
}
/*
@@ -1375,148 +1211,115 @@ BinASTParser<Tok>::parseFunctionDeclarat
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassDeclaration:
MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("FunctionDeclarationOrClassDeclarationOrExpression", kind);
}
return result;
}
/*
@@ -1540,32 +1343,28 @@ BinASTParser<Tok>::parseFunctionDeclarat
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ClassDeclaration:
MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields));
-
break;
case BinKind::EagerFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::SkippableFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::VariableDeclaration:
MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields));
-
break;
default:
return raiseInvalidKind("FunctionDeclarationOrClassDeclarationOrVariableDeclaration", kind);
}
return result;
}
/*
@@ -1587,24 +1386,22 @@ BinASTParser<Tok>::parseFunctionExpressi
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("FunctionExpression", kind);
}
return result;
}
/*
@@ -1626,24 +1423,22 @@ BinASTParser<Tok>::parseGetter()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumGetter(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerGetter:
MOZ_TRY_VAR(result, parseInterfaceEagerGetter(start, kind, fields));
-
break;
case BinKind::SkippableGetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableGetter(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Getter", kind);
}
return result;
}
/*
@@ -1665,24 +1460,22 @@ BinASTParser<Tok>::parseImportDeclaratio
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::Import:
MOZ_TRY_VAR(result, parseInterfaceImport(start, kind, fields));
-
break;
case BinKind::ImportNamespace:
MOZ_TRY_VAR(result, parseInterfaceImportNamespace(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ImportDeclaration", kind);
}
return result;
}
/*
@@ -1733,140 +1526,109 @@ BinASTParser<Tok>::parseImportDeclaratio
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::Block:
MOZ_TRY_VAR(result, parseInterfaceBlock(start, kind, fields));
-
break;
case BinKind::BreakStatement:
MOZ_TRY_VAR(result, parseInterfaceBreakStatement(start, kind, fields));
-
break;
case BinKind::ClassDeclaration:
MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields));
-
break;
case BinKind::ContinueStatement:
MOZ_TRY_VAR(result, parseInterfaceContinueStatement(start, kind, fields));
-
break;
case BinKind::DebuggerStatement:
MOZ_TRY_VAR(result, parseInterfaceDebuggerStatement(start, kind, fields));
-
break;
case BinKind::DoWhileStatement:
MOZ_TRY_VAR(result, parseInterfaceDoWhileStatement(start, kind, fields));
-
break;
case BinKind::EagerFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::EmptyStatement:
MOZ_TRY_VAR(result, parseInterfaceEmptyStatement(start, kind, fields));
-
break;
case BinKind::Export:
MOZ_TRY_VAR(result, parseInterfaceExport(start, kind, fields));
-
break;
case BinKind::ExportAllFrom:
MOZ_TRY_VAR(result, parseInterfaceExportAllFrom(start, kind, fields));
-
break;
case BinKind::ExportDefault:
MOZ_TRY_VAR(result, parseInterfaceExportDefault(start, kind, fields));
-
break;
case BinKind::ExportFrom:
MOZ_TRY_VAR(result, parseInterfaceExportFrom(start, kind, fields));
-
break;
case BinKind::ExportLocals:
MOZ_TRY_VAR(result, parseInterfaceExportLocals(start, kind, fields));
-
break;
case BinKind::ExpressionStatement:
MOZ_TRY_VAR(result, parseInterfaceExpressionStatement(start, kind, fields));
-
break;
case BinKind::ForInStatement:
MOZ_TRY_VAR(result, parseInterfaceForInStatement(start, kind, fields));
-
break;
case BinKind::ForOfStatement:
MOZ_TRY_VAR(result, parseInterfaceForOfStatement(start, kind, fields));
-
break;
case BinKind::ForStatement:
MOZ_TRY_VAR(result, parseInterfaceForStatement(start, kind, fields));
-
break;
case BinKind::IfStatement:
MOZ_TRY_VAR(result, parseInterfaceIfStatement(start, kind, fields));
-
break;
case BinKind::Import:
MOZ_TRY_VAR(result, parseInterfaceImport(start, kind, fields));
-
break;
case BinKind::ImportNamespace:
MOZ_TRY_VAR(result, parseInterfaceImportNamespace(start, kind, fields));
-
break;
case BinKind::LabelledStatement:
MOZ_TRY_VAR(result, parseInterfaceLabelledStatement(start, kind, fields));
-
break;
case BinKind::ReturnStatement:
MOZ_TRY_VAR(result, parseInterfaceReturnStatement(start, kind, fields));
-
break;
case BinKind::SkippableFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::SwitchStatement:
MOZ_TRY_VAR(result, parseInterfaceSwitchStatement(start, kind, fields));
-
break;
case BinKind::SwitchStatementWithDefault:
MOZ_TRY_VAR(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields));
-
break;
case BinKind::ThrowStatement:
MOZ_TRY_VAR(result, parseInterfaceThrowStatement(start, kind, fields));
-
break;
case BinKind::TryCatchStatement:
MOZ_TRY_VAR(result, parseInterfaceTryCatchStatement(start, kind, fields));
-
break;
case BinKind::TryFinallyStatement:
MOZ_TRY_VAR(result, parseInterfaceTryFinallyStatement(start, kind, fields));
-
break;
case BinKind::VariableDeclaration:
MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields));
-
break;
case BinKind::WhileStatement:
MOZ_TRY_VAR(result, parseInterfaceWhileStatement(start, kind, fields));
-
break;
case BinKind::WithStatement:
MOZ_TRY_VAR(result, parseInterfaceWithStatement(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ImportDeclarationOrExportDeclarationOrStatement", kind);
}
return result;
}
/*
@@ -1891,36 +1653,31 @@ BinASTParser<Tok>::parseIterationStateme
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::DoWhileStatement:
MOZ_TRY_VAR(result, parseInterfaceDoWhileStatement(start, kind, fields));
-
break;
case BinKind::ForInStatement:
MOZ_TRY_VAR(result, parseInterfaceForInStatement(start, kind, fields));
-
break;
case BinKind::ForOfStatement:
MOZ_TRY_VAR(result, parseInterfaceForOfStatement(start, kind, fields));
-
break;
case BinKind::ForStatement:
MOZ_TRY_VAR(result, parseInterfaceForStatement(start, kind, fields));
-
break;
case BinKind::WhileStatement:
MOZ_TRY_VAR(result, parseInterfaceWhileStatement(start, kind, fields));
-
break;
default:
return raiseInvalidKind("IterationStatement", kind);
}
return result;
}
/*
@@ -1945,36 +1702,31 @@ BinASTParser<Tok>::parseLiteral()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Literal", kind);
}
return result;
}
/*
@@ -1996,24 +1748,22 @@ BinASTParser<Tok>::parseMethod()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumMethod(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerMethod:
MOZ_TRY_VAR(result, parseInterfaceEagerMethod(start, kind, fields));
-
break;
case BinKind::SkippableMethod:
MOZ_TRY_VAR(result, parseInterfaceSkippableMethod(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Method", kind);
}
return result;
}
/*
@@ -2039,40 +1789,34 @@ BinASTParser<Tok>::parseMethodDefinition
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerGetter:
MOZ_TRY_VAR(result, parseInterfaceEagerGetter(start, kind, fields));
-
break;
case BinKind::EagerMethod:
MOZ_TRY_VAR(result, parseInterfaceEagerMethod(start, kind, fields));
-
break;
case BinKind::EagerSetter:
MOZ_TRY_VAR(result, parseInterfaceEagerSetter(start, kind, fields));
-
break;
case BinKind::SkippableGetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableGetter(start, kind, fields));
-
break;
case BinKind::SkippableMethod:
MOZ_TRY_VAR(result, parseInterfaceSkippableMethod(start, kind, fields));
-
break;
case BinKind::SkippableSetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableSetter(start, kind, fields));
-
break;
default:
return raiseInvalidKind("MethodDefinition", kind);
}
return result;
}
/*
@@ -2100,48 +1844,40 @@ BinASTParser<Tok>::parseObjectProperty()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::DataProperty:
MOZ_TRY_VAR(result, parseInterfaceDataProperty(start, kind, fields));
-
break;
case BinKind::EagerGetter:
MOZ_TRY_VAR(result, parseInterfaceEagerGetter(start, kind, fields));
-
break;
case BinKind::EagerMethod:
MOZ_TRY_VAR(result, parseInterfaceEagerMethod(start, kind, fields));
-
break;
case BinKind::EagerSetter:
MOZ_TRY_VAR(result, parseInterfaceEagerSetter(start, kind, fields));
-
break;
case BinKind::ShorthandProperty:
MOZ_TRY_VAR(result, parseInterfaceShorthandProperty(start, kind, fields));
-
break;
case BinKind::SkippableGetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableGetter(start, kind, fields));
-
break;
case BinKind::SkippableMethod:
MOZ_TRY_VAR(result, parseInterfaceSkippableMethod(start, kind, fields));
-
break;
case BinKind::SkippableSetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableSetter(start, kind, fields));
-
break;
default:
return raiseInvalidKind("ObjectProperty", kind);
}
return result;
}
/*
@@ -2165,35 +1901,32 @@ BinASTParser<Tok>::parseParameter()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayBinding:
MOZ_TRY_VAR(result, parseInterfaceArrayBinding(start, kind, fields));
-
break;
case BinKind::BindingIdentifier:
MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields));
if (!parseContext_->positionalFormalParameterNames().append(result->pn_atom))
return raiseOOM();
if (parseContext_->isFunctionBox())
parseContext_->functionBox()->length++;
break;
case BinKind::BindingWithInitializer:
MOZ_TRY_VAR(result, parseInterfaceBindingWithInitializer(start, kind, fields));
-
break;
case BinKind::ObjectBinding:
MOZ_TRY_VAR(result, parseInterfaceObjectBinding(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Parameter", kind);
}
return result;
}
/*
@@ -2215,24 +1948,22 @@ BinASTParser<Tok>::parseProgram()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::Module:
MOZ_TRY_VAR(result, parseInterfaceModule(start, kind, fields));
-
break;
case BinKind::Script:
MOZ_TRY_VAR(result, parseInterfaceScript(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Program", kind);
}
return result;
}
/*
@@ -2254,24 +1985,22 @@ BinASTParser<Tok>::parsePropertyName()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ComputedPropertyName:
MOZ_TRY_VAR(result, parseInterfaceComputedPropertyName(start, kind, fields));
-
break;
case BinKind::LiteralPropertyName:
MOZ_TRY_VAR(result, parseInterfaceLiteralPropertyName(start, kind, fields));
-
break;
default:
return raiseInvalidKind("PropertyName", kind);
}
return result;
}
/*
@@ -2293,24 +2022,22 @@ BinASTParser<Tok>::parseSetter()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumSetter(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::EagerSetter:
MOZ_TRY_VAR(result, parseInterfaceEagerSetter(start, kind, fields));
-
break;
case BinKind::SkippableSetter:
MOZ_TRY_VAR(result, parseInterfaceSkippableSetter(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Setter", kind);
}
return result;
}
/*
@@ -2333,28 +2060,25 @@ BinASTParser<Tok>::parseSimpleAssignment
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::AssignmentTargetIdentifier:
MOZ_TRY_VAR(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
-
break;
case BinKind::ComputedMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
-
break;
case BinKind::StaticMemberAssignmentTarget:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
-
break;
default:
return raiseInvalidKind("SimpleAssignmentTarget", kind);
}
return result;
}
/*
@@ -2405,140 +2129,109 @@ BinASTParser<Tok>::parseSpreadElementOrE
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::SpreadElement:
MOZ_TRY_VAR(result, parseInterfaceSpreadElement(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("SpreadElementOrExpression", kind);
}
return result;
}
/*
@@ -2582,112 +2275,88 @@ BinASTParser<Tok>::parseStatement()
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::Block:
MOZ_TRY_VAR(result, parseInterfaceBlock(start, kind, fields));
-
break;
case BinKind::BreakStatement:
MOZ_TRY_VAR(result, parseInterfaceBreakStatement(start, kind, fields));
-
break;
case BinKind::ClassDeclaration:
MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields));
-
break;
case BinKind::ContinueStatement:
MOZ_TRY_VAR(result, parseInterfaceContinueStatement(start, kind, fields));
-
break;
case BinKind::DebuggerStatement:
MOZ_TRY_VAR(result, parseInterfaceDebuggerStatement(start, kind, fields));
-
break;
case BinKind::DoWhileStatement:
MOZ_TRY_VAR(result, parseInterfaceDoWhileStatement(start, kind, fields));
-
break;
case BinKind::EagerFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::EmptyStatement:
MOZ_TRY_VAR(result, parseInterfaceEmptyStatement(start, kind, fields));
-
break;
case BinKind::ExpressionStatement:
MOZ_TRY_VAR(result, parseInterfaceExpressionStatement(start, kind, fields));
-
break;
case BinKind::ForInStatement:
MOZ_TRY_VAR(result, parseInterfaceForInStatement(start, kind, fields));
-
break;
case BinKind::ForOfStatement:
MOZ_TRY_VAR(result, parseInterfaceForOfStatement(start, kind, fields));
-
break;
case BinKind::ForStatement:
MOZ_TRY_VAR(result, parseInterfaceForStatement(start, kind, fields));
-
break;
case BinKind::IfStatement:
MOZ_TRY_VAR(result, parseInterfaceIfStatement(start, kind, fields));
-
break;
case BinKind::LabelledStatement:
MOZ_TRY_VAR(result, parseInterfaceLabelledStatement(start, kind, fields));
-
break;
case BinKind::ReturnStatement:
MOZ_TRY_VAR(result, parseInterfaceReturnStatement(start, kind, fields));
-
break;
case BinKind::SkippableFunctionDeclaration:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
-
break;
case BinKind::SwitchStatement:
MOZ_TRY_VAR(result, parseInterfaceSwitchStatement(start, kind, fields));
-
break;
case BinKind::SwitchStatementWithDefault:
MOZ_TRY_VAR(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields));
-
break;
case BinKind::ThrowStatement:
MOZ_TRY_VAR(result, parseInterfaceThrowStatement(start, kind, fields));
-
break;
case BinKind::TryCatchStatement:
MOZ_TRY_VAR(result, parseInterfaceTryCatchStatement(start, kind, fields));
-
break;
case BinKind::TryFinallyStatement:
MOZ_TRY_VAR(result, parseInterfaceTryFinallyStatement(start, kind, fields));
-
break;
case BinKind::VariableDeclaration:
MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields));
-
break;
case BinKind::WhileStatement:
MOZ_TRY_VAR(result, parseInterfaceWhileStatement(start, kind, fields));
-
break;
case BinKind::WithStatement:
MOZ_TRY_VAR(result, parseInterfaceWithStatement(start, kind, fields));
-
break;
default:
return raiseInvalidKind("Statement", kind);
}
return result;
}
/*
@@ -2738,140 +2407,109 @@ BinASTParser<Tok>::parseVariableDeclarat
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
ParseNode* result;
- switch(kind) {
+ switch (kind) {
case BinKind::ArrayExpression:
MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
-
break;
case BinKind::AssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceAssignmentExpression(start, kind, fields));
-
break;
case BinKind::AwaitExpression:
MOZ_TRY_VAR(result, parseInterfaceAwaitExpression(start, kind, fields));
-
break;
case BinKind::BinaryExpression:
MOZ_TRY_VAR(result, parseInterfaceBinaryExpression(start, kind, fields));
-
break;
case BinKind::CallExpression:
MOZ_TRY_VAR(result, parseInterfaceCallExpression(start, kind, fields));
-
break;
case BinKind::ClassExpression:
MOZ_TRY_VAR(result, parseInterfaceClassExpression(start, kind, fields));
-
break;
case BinKind::CompoundAssignmentExpression:
MOZ_TRY_VAR(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-
break;
case BinKind::ComputedMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-
break;
case BinKind::ConditionalExpression:
MOZ_TRY_VAR(result, parseInterfaceConditionalExpression(start, kind, fields));
-
break;
case BinKind::EagerArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerArrowExpression(start, kind, fields));
-
break;
case BinKind::EagerFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
-
break;
case BinKind::IdentifierExpression:
MOZ_TRY_VAR(result, parseInterfaceIdentifierExpression(start, kind, fields));
-
break;
case BinKind::LiteralBooleanExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-
break;
case BinKind::LiteralInfinityExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-
break;
case BinKind::LiteralNullExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-
break;
case BinKind::LiteralNumericExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-
break;
case BinKind::LiteralRegExpExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-
break;
case BinKind::LiteralStringExpression:
MOZ_TRY_VAR(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-
break;
case BinKind::NewExpression:
MOZ_TRY_VAR(result, parseInterfaceNewExpression(start, kind, fields));
-
break;
case BinKind::NewTargetExpression:
MOZ_TRY_VAR(result, parseInterfaceNewTargetExpression(start, kind, fields));
-
break;
case BinKind::ObjectExpression:
MOZ_TRY_VAR(result, parseInterfaceObjectExpression(start, kind, fields));
-
break;
case BinKind::SkippableArrowExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
-
break;
case BinKind::SkippableFunctionExpression:
MOZ_TRY_VAR(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
-
break;
case BinKind::StaticMemberExpression:
MOZ_TRY_VAR(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-
break;
case BinKind::TemplateExpression:
MOZ_TRY_VAR(result, parseInterfaceTemplateExpression(start, kind, fields));
-
break;
case BinKind::ThisExpression:
MOZ_TRY_VAR(result, parseInterfaceThisExpression(start, kind, fields));
-
break;
case BinKind::UnaryExpression:
MOZ_TRY_VAR(result, parseInterfaceUnaryExpression(start, kind, fields));
-
break;
case BinKind::UpdateExpression:
MOZ_TRY_VAR(result, parseInterfaceUpdateExpression(start, kind, fields));
-
break;
case BinKind::VariableDeclaration:
MOZ_TRY_VAR(result, parseInterfaceVariableDeclaration(start, kind, fields));
-
break;
case BinKind::YieldExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldExpression(start, kind, fields));
-
break;
case BinKind::YieldStarExpression:
MOZ_TRY_VAR(result, parseInterfaceYieldStarExpression(start, kind, fields));
-
break;
default:
return raiseInvalidKind("VariableDeclarationOrExpression", kind);
}
return result;
}
@@ -2886,18 +2524,20 @@ BinASTParser<Tok>::parseSumVariableDecla
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseNull()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::_Null) {
+ return raiseInvalidKind("_Null", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceNull(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceNull(const size_t start, const BinKind kind, const BinFields& fields)
@@ -2915,18 +2555,20 @@ BinASTParser<Tok>::parseInterfaceNull(co
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseArrayAssignmentTarget()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ArrayAssignmentTarget) {
+ return raiseInvalidKind("ArrayAssignmentTarget", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceArrayAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
@@ -2944,18 +2586,20 @@ BinASTParser<Tok>::parseInterfaceArrayAs
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseArrayBinding()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ArrayBinding) {
+ return raiseInvalidKind("ArrayBinding", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayBinding(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceArrayBinding(const size_t start, const BinKind kind, const BinFields& fields)
@@ -2972,42 +2616,39 @@ BinASTParser<Tok>::parseInterfaceArrayBi
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseArrayExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ArrayExpression) {
+ return raiseInvalidKind("ArrayExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceArrayExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ArrayExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Elements };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(elements, parseListOfOptionalSpreadElementOrExpression());
-
auto result = elements;
return result;
}
/*
interface AssertedBlockScope : Node {
FrozenArray<IdentifierName> lexicallyDeclaredNames;
@@ -3018,47 +2659,44 @@ BinASTParser<Tok>::parseInterfaceArrayEx
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseAssertedBlockScope()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssertedBlockScope) {
+ return raiseInvalidKind("AssertedBlockScope", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedBlockScope(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseInterfaceAssertedBlockScope(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::AssertedBlockScope);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::LexicallyDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let));
MOZ_TRY(parseAndUpdateCapturedNames(kind));
-
-
BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool());
if (hasDirectEval) {
parseContext_->sc()->setHasDirectEval();
parseContext_->sc()->setBindingsAccessedDynamically();
}
-
if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) {
// In non-strict mode code, direct calls to eval can
// add variables to the call object.
parseContext_->functionBox()->setHasExtensibleScope();
}
auto result = Ok();
return result;
}
@@ -3074,55 +2712,52 @@ BinASTParser<Tok>::parseInterfaceAsserte
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseAssertedParameterScope()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssertedParameterScope) {
+ return raiseInvalidKind("AssertedParameterScope", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedParameterScope(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseInterfaceAssertedParameterScope(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::AssertedParameterScope);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::ParameterNames, BinField::CapturedNames, BinField::HasDirectEval };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
ParseContext::Statement* inStatement = parseContext_->innermostStatement();
// If we are in a `CatchClause`, the binding is a implicit CatchParameter
// and it goes into the innermost scope. Otherwise, we're in a function,
// so it goes in the function scope.
if (inStatement && inStatement->kind() == StatementKind::Catch)
MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::CatchParameter));
else
MOZ_TRY(parseAndUpdateScopeNames(parseContext_->functionScope(), DeclarationKind::PositionalFormalParameter));
MOZ_TRY(parseAndUpdateCapturedNames(kind));
-
-
BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool());
if (hasDirectEval) {
parseContext_->sc()->setHasDirectEval();
parseContext_->sc()->setBindingsAccessedDynamically();
}
-
if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) {
// In non-strict mode code, direct calls to eval can
// add variables to the call object.
parseContext_->functionBox()->setHasExtensibleScope();
}
auto result = Ok();
return result;
}
@@ -3139,48 +2774,45 @@ BinASTParser<Tok>::parseInterfaceAsserte
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseAssertedVarScope()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssertedVarScope) {
+ return raiseInvalidKind("AssertedVarScope", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssertedVarScope(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseInterfaceAssertedVarScope(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::AssertedVarScope);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[4] = { BinField::LexicallyDeclaredNames, BinField::VarDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let));
MOZ_TRY(parseAndUpdateScopeNames(parseContext_->varScope(), DeclarationKind::Var));
MOZ_TRY(parseAndUpdateCapturedNames(kind));
-
-
BINJS_MOZ_TRY_DECL(hasDirectEval, tokenizer_->readBool());
if (hasDirectEval) {
parseContext_->sc()->setHasDirectEval();
parseContext_->sc()->setBindingsAccessedDynamically();
}
-
if (hasDirectEval && parseContext_->isFunctionBox() && !parseContext_->sc()->strict()) {
// In non-strict mode code, direct calls to eval can
// add variables to the call object.
parseContext_->functionBox()->setHasExtensibleScope();
}
auto result = Ok();
return result;
}
@@ -3195,47 +2827,41 @@ BinASTParser<Tok>::parseInterfaceAsserte
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAssignmentExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssignmentExpression) {
+ return raiseInvalidKind("AssignmentExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::AssignmentExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Binding, BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(binding, parseAssignmentTarget());
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression));
return result;
}
/*
interface AssignmentTargetIdentifier : Node {
Identifier name;
@@ -3244,42 +2870,40 @@ BinASTParser<Tok>::parseInterfaceAssignm
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAssignmentTargetIdentifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssignmentTargetIdentifier) {
+ return raiseInvalidKind("AssignmentTargetIdentifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAssignmentTargetIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::AssignmentTargetIdentifier);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Name };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom name(cx_);
MOZ_TRY_VAR(name, tokenizer_->readAtom());
-
if (!IsIdentifier(name))
return raiseError("Invalid identifier");
BINJS_TRY(usedNames_.noteUse(cx_, name, parseContext_->scriptId(), parseContext_->innermostScope()->id()));
BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
return result;
}
@@ -3292,18 +2916,20 @@ BinASTParser<Tok>::parseInterfaceAssignm
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAssignmentTargetPropertyIdentifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssignmentTargetPropertyIdentifier) {
+ return raiseInvalidKind("AssignmentTargetPropertyIdentifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyIdentifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3321,18 +2947,20 @@ BinASTParser<Tok>::parseInterfaceAssignm
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAssignmentTargetPropertyProperty()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssignmentTargetPropertyProperty) {
+ return raiseInvalidKind("AssignmentTargetPropertyProperty", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyProperty(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3350,18 +2978,20 @@ BinASTParser<Tok>::parseInterfaceAssignm
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAssignmentTargetWithInitializer()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AssignmentTargetWithInitializer) {
+ return raiseInvalidKind("AssignmentTargetWithInitializer", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetWithInitializer(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3378,18 +3008,20 @@ BinASTParser<Tok>::parseInterfaceAssignm
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseAwaitExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::AwaitExpression) {
+ return raiseInvalidKind("AwaitExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceAwaitExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceAwaitExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3408,52 +3040,43 @@ BinASTParser<Tok>::parseInterfaceAwaitEx
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBinaryExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BinaryExpression) {
+ return raiseInvalidKind("BinaryExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBinaryExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBinaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::BinaryExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Operator, BinField::Left, BinField::Right };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(operator_, parseBinaryOperator());
-
-
-
BINJS_MOZ_TRY_DECL(left, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(right, parseExpression());
-
ParseNodeKind pnk;
switch (operator_) {
case BinaryOperator::Comma:
pnk = ParseNodeKind::Comma;
break;
case BinaryOperator::LogicalOr:
pnk = ParseNodeKind::Or;
break;
@@ -3554,42 +3177,40 @@ BinASTParser<Tok>::parseInterfaceBinaryE
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBindingIdentifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BindingIdentifier) {
+ return raiseInvalidKind("BindingIdentifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingIdentifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBindingIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::BindingIdentifier);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Name };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom name(cx_);
MOZ_TRY_VAR(name, tokenizer_->readAtom());
-
if (!IsIdentifier(name))
return raiseError("Invalid identifier");
BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
return result;
}
/*
@@ -3601,18 +3222,20 @@ BinASTParser<Tok>::parseInterfaceBinding
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBindingPropertyIdentifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BindingPropertyIdentifier) {
+ return raiseInvalidKind("BindingPropertyIdentifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingPropertyIdentifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBindingPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3630,18 +3253,20 @@ BinASTParser<Tok>::parseInterfaceBinding
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBindingPropertyProperty()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BindingPropertyProperty) {
+ return raiseInvalidKind("BindingPropertyProperty", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingPropertyProperty(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBindingPropertyProperty(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3659,18 +3284,20 @@ BinASTParser<Tok>::parseInterfaceBinding
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBindingWithInitializer()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BindingWithInitializer) {
+ return raiseInvalidKind("BindingWithInitializer", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBindingWithInitializer(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3688,49 +3315,44 @@ BinASTParser<Tok>::parseInterfaceBinding
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBlock()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Block) {
+ return raiseInvalidKind("Block", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBlock(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBlock(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::Block);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Scope, BinField::Statements };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
ParseContext::Statement stmt(parseContext_, StatementKind::Block);
ParseContext::Scope currentScope(cx_, parseContext_, usedNames_);
BINJS_TRY(currentScope.init(parseContext_));
-
MOZ_TRY(parseOptionalAssertedBlockScope());
-
-
-
BINJS_MOZ_TRY_DECL(statements, parseListOfStatement());
-
MOZ_TRY(checkClosedVars(currentScope));
BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_));
BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, statements));
return result;
}
/*
@@ -3741,36 +3363,36 @@ BinASTParser<Tok>::parseInterfaceBlock(c
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseBreakStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::BreakStatement) {
+ return raiseInvalidKind("BreakStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceBreakStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceBreakStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::BreakStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Label };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
RootedAtom label(cx_);
MOZ_TRY_VAR(label, tokenizer_->readMaybeAtom());
if (label) {
if (!IsIdentifier(label))
return raiseError("Invalid identifier");
auto validity = parseContext_->checkBreakStatement(label->asPropertyName());
@@ -3798,47 +3420,41 @@ BinASTParser<Tok>::parseInterfaceBreakSt
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseCallExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::CallExpression) {
+ return raiseInvalidKind("CallExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceCallExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceCallExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::CallExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Callee, BinField::Arguments };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(callee, parseExpressionOrSuper());
-
-
-
BINJS_MOZ_TRY_DECL(arguments, parseArguments());
-
auto op = JSOP_CALL;
// Check for direct calls to `eval`.
if (factory_.isEvalName(callee, cx_)) {
if (!parseContext_->varScope().lookupDeclaredNameForAdd(callee->name())
&& !parseContext_->innermostScope()->lookupDeclaredNameForAdd(callee->name())) {
// This is a direct call to `eval`.
if (!parseContext_->sc()->hasDirectEval())
return raiseMissingDirectEvalInAssertedScope();
@@ -3864,54 +3480,46 @@ BinASTParser<Tok>::parseInterfaceCallExp
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseCatchClause()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::CatchClause) {
+ return raiseInvalidKind("CatchClause", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceCatchClause(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceCatchClause(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::CatchClause);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
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(parseContext_, StatementKind::Catch);
ParseContext::Scope currentScope(cx_, parseContext_, usedNames_);
BINJS_TRY(currentScope.init(parseContext_));
-
MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
BINJS_MOZ_TRY_DECL(binding, parseBinding());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseBlock());
-
BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_));
BINJS_TRY_DECL(result, factory_.newLexicalScope(*bindings, body));
BINJS_TRY(factory_.setupCatchScope(result, binding, body));
return result;
}
/*
@@ -3924,18 +3532,20 @@ BinASTParser<Tok>::parseInterfaceCatchCl
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseClassDeclaration()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ClassDeclaration) {
+ return raiseInvalidKind("ClassDeclaration", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceClassDeclaration(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceClassDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3953,18 +3563,20 @@ BinASTParser<Tok>::parseInterfaceClassDe
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseClassElement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ClassElement) {
+ return raiseInvalidKind("ClassElement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceClassElement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceClassElement(const size_t start, const BinKind kind, const BinFields& fields)
@@ -3983,18 +3595,20 @@ BinASTParser<Tok>::parseInterfaceClassEl
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseClassExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ClassExpression) {
+ return raiseInvalidKind("ClassExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceClassExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceClassExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -4013,52 +3627,43 @@ BinASTParser<Tok>::parseInterfaceClassEx
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseCompoundAssignmentExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::CompoundAssignmentExpression) {
+ return raiseInvalidKind("CompoundAssignmentExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceCompoundAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::CompoundAssignmentExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Operator, BinField::Binding, BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(operator_, parseCompoundAssignmentOperator());
-
-
-
BINJS_MOZ_TRY_DECL(binding, parseSimpleAssignmentTarget());
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
ParseNodeKind pnk;
switch (operator_){
case CompoundAssignmentOperator::PlusAssign:
pnk = ParseNodeKind::AddAssign;
break;
case CompoundAssignmentOperator::MinusAssign:
pnk = ParseNodeKind::SubAssign;
break;
@@ -4107,47 +3712,41 @@ BinASTParser<Tok>::parseInterfaceCompoun
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseComputedMemberAssignmentTarget()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ComputedMemberAssignmentTarget) {
+ return raiseInvalidKind("ComputedMemberAssignmentTarget", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceComputedMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ComputedMemberAssignmentTarget);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Object, BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper());
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));
return result;
}
/*
interface ComputedMemberExpression : Node {
(Expression or Super) object;
@@ -4157,47 +3756,41 @@ BinASTParser<Tok>::parseInterfaceCompute
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseComputedMemberExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ComputedMemberExpression) {
+ return raiseInvalidKind("ComputedMemberExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedMemberExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceComputedMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ComputedMemberExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Object, BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper());
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));
return result;
}
/*
interface ComputedPropertyName : Node {
Expression expression;
@@ -4206,18 +3799,20 @@ BinASTParser<Tok>::parseInterfaceCompute
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseComputedPropertyName()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ComputedPropertyName) {
+ return raiseInvalidKind("ComputedPropertyName", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceComputedPropertyName(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceComputedPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
@@ -4236,52 +3831,43 @@ BinASTParser<Tok>::parseInterfaceCompute
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseConditionalExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ConditionalExpression) {
+ return raiseInvalidKind("ConditionalExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceConditionalExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ConditionalExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Test, BinField::Consequent, BinField::Alternate };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(test, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(consequent, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(alternate, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newConditional(test, consequent, alternate));
return result;
}
/*
interface ContinueStatement : Node {
Label? label;
@@ -4290,36 +3876,36 @@ BinASTParser<Tok>::parseInterfaceConditi
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseContinueStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ContinueStatement) {
+ return raiseInvalidKind("ContinueStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceContinueStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceContinueStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ContinueStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Label };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
RootedAtom label(cx_);
MOZ_TRY_VAR(label, tokenizer_->readMaybeAtom());
if (label) {
if (!IsIdentifier(label))
return raiseError("ContinueStatement - Label MUST be an identifier");
auto validity = parseContext_->checkContinueStatement(label ? label->asPropertyName() : nullptr);
@@ -4347,47 +3933,41 @@ BinASTParser<Tok>::parseInterfaceContinu
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseDataProperty()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::DataProperty) {
+ return raiseInvalidKind("DataProperty", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceDataProperty(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceDataProperty(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::DataProperty);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Name, BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(name, parsePropertyName());
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
if (!factory_.isUsableAsObjectPropertyName(name))
return raiseError("DataProperty key kind");
BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None));
return result;
}
@@ -4398,18 +3978,20 @@ BinASTParser<Tok>::parseInterfaceDataPro
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseDebuggerStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::DebuggerStatement) {
+ return raiseInvalidKind("DebuggerStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceDebuggerStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceDebuggerStatement(const size_t start, const BinKind kind, const BinFields& fields)
@@ -4426,42 +4008,40 @@ BinASTParser<Tok>::parseInterfaceDebugge
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseDirective()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Directive) {
+ return raiseInvalidKind("Directive", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceDirective(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceDirective(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::Directive);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::RawValue };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom rawValue(cx_);
MOZ_TRY_VAR(rawValue, tokenizer_->readAtom());
-
TokenPos pos = tokenizer_->pos(start);
BINJS_TRY_DECL(result, factory_.newStringLiteral(rawValue, pos));
return result;
}
/*
interface DoWhileStatement : Node {
@@ -4472,47 +4052,42 @@ BinASTParser<Tok>::parseInterfaceDirecti
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseDoWhileStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::DoWhileStatement) {
+ return raiseInvalidKind("DoWhileStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceDoWhileStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceDoWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::DoWhileStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Test, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
ParseContext::Statement stmt(parseContext_, StatementKind::DoLoop);
-
BINJS_MOZ_TRY_DECL(test, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start)));
return result;
}
/*
interface EagerArrowExpression : Node {
bool isAsync;
@@ -4525,18 +4100,20 @@ BinASTParser<Tok>::parseInterfaceDoWhile
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerArrowExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerArrowExpression) {
+ return raiseInvalidKind("EagerArrowExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerArrowExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerArrowExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -4559,86 +4136,67 @@ BinASTParser<Tok>::parseInterfaceEagerAr
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerFunctionDeclaration()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerFunctionDeclaration) {
+ return raiseInvalidKind("EagerFunctionDeclaration", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EagerFunctionDeclaration);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[7] = { BinField::IsAsync, BinField::IsGenerator, BinField::Name, BinField::ParameterScope, BinField::BodyScope, BinField::Params, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
const auto syntax = FunctionSyntaxKind::Statement;
-
BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(name, parseBindingIdentifier());
-
BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox(
isGenerator ? GeneratorKind::Generator
: GeneratorKind::NotGenerator,
isAsync ? FunctionAsyncKind::AsyncFunction
: FunctionAsyncKind::SyncFunction,
syntax, name));
// Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
parseContext_->functionScope().useAsVarScope(parseContext_);
MOZ_ASSERT(parseContext_->isFunctionBox());
ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
BINJS_TRY(lexicalScope.init(parseContext_));
-
MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(params, parseFormalParameters());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseFunctionBody());
-
BINJS_TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_));
BINJS_TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body));
BINJS_MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox));
return result;
}
/*
@@ -4655,86 +4213,67 @@ BinASTParser<Tok>::parseInterfaceEagerFu
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerFunctionExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerFunctionExpression) {
+ return raiseInvalidKind("EagerFunctionExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EagerFunctionExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[7] = { BinField::IsAsync, BinField::IsGenerator, BinField::Name, BinField::ParameterScope, BinField::BodyScope, BinField::Params, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
const auto syntax = FunctionSyntaxKind::Expression;
-
BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(name, parseOptionalBindingIdentifier());
-
BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox(
isGenerator ? GeneratorKind::Generator
: GeneratorKind::NotGenerator,
isAsync ? FunctionAsyncKind::AsyncFunction
: FunctionAsyncKind::SyncFunction,
syntax, name));
// Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
parseContext_->functionScope().useAsVarScope(parseContext_);
MOZ_ASSERT(parseContext_->isFunctionBox());
ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
BINJS_TRY(lexicalScope.init(parseContext_));
-
MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(params, parseFormalParameters());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseFunctionBody());
-
BINJS_TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_));
BINJS_TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body));
BINJS_MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox));
return result;
}
/*
@@ -4747,64 +4286,55 @@ BinASTParser<Tok>::parseInterfaceEagerFu
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerGetter()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerGetter) {
+ return raiseInvalidKind("EagerGetter", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerGetter(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerGetter(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EagerGetter);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Name, BinField::BodyScope, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(name, parsePropertyName());
BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox(
GeneratorKind::NotGenerator,
FunctionAsyncKind::SyncFunction,
FunctionSyntaxKind::Getter, /* name = */ nullptr));
// Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
parseContext_->functionScope().useAsVarScope(parseContext_);
MOZ_ASSERT(parseContext_->isFunctionBox());
ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
BINJS_TRY(lexicalScope.init(parseContext_));
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseFunctionBody());
-
BINJS_TRY_DECL(params, new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start)));
BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox));
BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Getter));
return result;
}
/*
@@ -4821,86 +4351,67 @@ BinASTParser<Tok>::parseInterfaceEagerGe
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerMethod()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerMethod) {
+ return raiseInvalidKind("EagerMethod", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerMethod(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerMethod(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EagerMethod);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[7] = { BinField::IsAsync, BinField::IsGenerator, BinField::Name, BinField::ParameterScope, BinField::BodyScope, BinField::Params, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
const auto syntax = FunctionSyntaxKind::Method;
-
BINJS_MOZ_TRY_DECL(isAsync, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(isGenerator, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(name, parsePropertyName());
-
BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox(
isGenerator ? GeneratorKind::Generator
: GeneratorKind::NotGenerator,
isAsync ? FunctionAsyncKind::AsyncFunction
: FunctionAsyncKind::SyncFunction,
syntax, name));
// Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
parseContext_->functionScope().useAsVarScope(parseContext_);
MOZ_ASSERT(parseContext_->isFunctionBox());
ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
BINJS_TRY(lexicalScope.init(parseContext_));
-
MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(params, parseFormalParameters());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseFunctionBody());
-
BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox));
BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None));
return result;
}
/*
interface EagerSetter : Node {
@@ -4914,74 +4425,59 @@ BinASTParser<Tok>::parseInterfaceEagerMe
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEagerSetter()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EagerSetter) {
+ return raiseInvalidKind("EagerSetter", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEagerSetter(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEagerSetter(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EagerSetter);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[5] = { BinField::Name, BinField::ParameterScope, BinField::BodyScope, BinField::Param, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(name, parsePropertyName());
BINJS_MOZ_TRY_DECL(funbox, buildFunctionBox(
GeneratorKind::NotGenerator,
FunctionAsyncKind::SyncFunction,
FunctionSyntaxKind::Setter, /* name = */ nullptr));
// Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
BINJS_TRY(funpc.init());
parseContext_->functionScope().useAsVarScope(parseContext_);
MOZ_ASSERT(parseContext_->isFunctionBox());
ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
BINJS_TRY(lexicalScope.init(parseContext_));
-
-
-
MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(param, parseParameter());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseFunctionBody());
-
BINJS_TRY_DECL(params, new_<ListNode>(ParseNodeKind::ParamsBody, param->pn_pos));
factory_.addList(params, param);
BINJS_MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox));
BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter));
return result;
}
@@ -4992,30 +4488,31 @@ BinASTParser<Tok>::parseInterfaceEagerSe
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseEmptyStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::EmptyStatement) {
+ return raiseInvalidKind("EmptyStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceEmptyStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceEmptyStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::EmptyStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
MOZ_TRY(tokenizer_->checkFields0(kind, fields));
BINJS_TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start)));
return result;
}
/*
@@ -5026,18 +4523,20 @@ MOZ_TRY(tokenizer_->checkFields0(kind, f
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExport()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Export) {
+ return raiseInvalidKind("Export", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExport(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExport(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5054,18 +4553,20 @@ BinASTParser<Tok>::parseInterfaceExport(
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportAllFrom()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportAllFrom) {
+ return raiseInvalidKind("ExportAllFrom", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportAllFrom(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportAllFrom(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5082,18 +4583,20 @@ BinASTParser<Tok>::parseInterfaceExportA
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportDefault()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportDefault) {
+ return raiseInvalidKind("ExportDefault", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportDefault(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportDefault(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5111,18 +4614,20 @@ BinASTParser<Tok>::parseInterfaceExportD
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportFrom()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportFrom) {
+ return raiseInvalidKind("ExportFrom", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportFrom(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportFrom(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5140,18 +4645,20 @@ BinASTParser<Tok>::parseInterfaceExportF
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportFromSpecifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportFromSpecifier) {
+ return raiseInvalidKind("ExportFromSpecifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportFromSpecifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportFromSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5169,18 +4676,20 @@ BinASTParser<Tok>::parseInterfaceExportF
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportLocalSpecifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportLocalSpecifier) {
+ return raiseInvalidKind("ExportLocalSpecifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportLocalSpecifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportLocalSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5197,18 +4706,20 @@ BinASTParser<Tok>::parseInterfaceExportL
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExportLocals()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExportLocals) {
+ return raiseInvalidKind("ExportLocals", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExportLocals(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExportLocals(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5225,42 +4736,39 @@ BinASTParser<Tok>::parseInterfaceExportL
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseExpressionStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ExpressionStatement) {
+ return raiseInvalidKind("ExpressionStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceExpressionStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ExpressionStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset()));
return result;
}
/*
interface ForInOfBinding : Node {
VariableDeclarationKind kind;
@@ -5270,47 +4778,42 @@ BinASTParser<Tok>::parseInterfaceExpress
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseForInOfBinding()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ForInOfBinding) {
+ return raiseInvalidKind("ForInOfBinding", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceForInOfBinding(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceForInOfBinding(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ForInOfBinding);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Kind, BinField::Binding };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
AutoVariableDeclarationKind kindGuard(this);
-
BINJS_MOZ_TRY_DECL(kind_, parseVariableDeclarationKind());
-
-
-
BINJS_MOZ_TRY_DECL(binding, parseBinding());
-
// Restored by `kindGuard`.
variableDeclarationKind_ = kind_;
MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName()));
auto pnk =
kind_ == VariableDeclarationKind::Let
? ParseNodeKind::Let
: ParseNodeKind::Var;
BINJS_TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start)));
@@ -5329,58 +4832,50 @@ BinASTParser<Tok>::parseInterfaceForInOf
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseForInStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ForInStatement) {
+ return raiseInvalidKind("ForInStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceForInStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceForInStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ForInStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
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(parseContext_, StatementKind::ForInLoop);
// Implicit scope around the `for`, used to store `for (let x in ...)`
// or `for (const x in ...)`-style declarations. Detail on the
// declaration is stored as part of `scope`.
ParseContext::Scope scope(cx_, parseContext_, usedNames_);
BINJS_TRY(scope.init(parseContext_));
-
BINJS_MOZ_TRY_DECL(left, parseForInOfBindingOrAssignmentTarget());
-
-
-
BINJS_MOZ_TRY_DECL(right, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start)));
BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0));
if (!scope.isEmpty()) {
BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
}
return result;
@@ -5397,18 +4892,20 @@ BinASTParser<Tok>::parseInterfaceForInSt
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseForOfStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ForOfStatement) {
+ return raiseInvalidKind("ForOfStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceForOfStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceForOfStatement(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5428,63 +4925,52 @@ BinASTParser<Tok>::parseInterfaceForOfSt
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseForStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ForStatement) {
+ return raiseInvalidKind("ForStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceForStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceForStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ForStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
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(parseContext_, StatementKind::ForLoop);
// Implicit scope around the `for`, used to store `for (let x; ...; ...)`
// or `for (const x; ...; ...)`-style declarations. Detail on the
// declaration is stored as part of `BINJS_Scope`.
ParseContext::Scope scope(cx_, parseContext_, usedNames_);
BINJS_TRY(scope.init(parseContext_));
-
BINJS_MOZ_TRY_DECL(init, parseOptionalVariableDeclarationOrExpression());
-
-
-
BINJS_MOZ_TRY_DECL(test, parseOptionalExpression());
-
-
-
BINJS_MOZ_TRY_DECL(update, parseOptionalExpression());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start)));
BINJS_TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0));
if (!scope.isEmpty()) {
BINJS_TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
BINJS_TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
}
return result;
@@ -5500,47 +4986,41 @@ BinASTParser<Tok>::parseInterfaceForStat
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseFormalParameters()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::FormalParameters) {
+ return raiseInvalidKind("FormalParameters", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceFormalParameters(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceFormalParameters(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::FormalParameters);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Items, BinField::Rest };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(items, parseListOfParameter());
-
-
-
BINJS_MOZ_TRY_DECL(rest, parseOptionalBinding());
-
auto result = items;
if (rest) {
BINJS_TRY_DECL(spread, factory_.newSpread(start, rest));
factory_.addList(result, spread);
}
return result;
}
@@ -5554,47 +5034,41 @@ BinASTParser<Tok>::parseInterfaceFormalP
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseFunctionBody()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::FunctionBody) {
+ return raiseInvalidKind("FunctionBody", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceFunctionBody(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::FunctionBody);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Directives, BinField::Statements };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(directives, parseListOfDirective());
-
-
-
BINJS_MOZ_TRY_DECL(statements, parseListOfStatement());
-
BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));
return result;
}
/*
interface IdentifierExpression : Node {
Identifier name;
@@ -5603,42 +5077,40 @@ BinASTParser<Tok>::parseInterfaceFunctio
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseIdentifierExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::IdentifierExpression) {
+ return raiseInvalidKind("IdentifierExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceIdentifierExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceIdentifierExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::IdentifierExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Name };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom name(cx_);
MOZ_TRY_VAR(name, tokenizer_->readAtom());
-
if (!IsIdentifier(name))
return raiseError("Invalid identifier");
BINJS_TRY(usedNames_.noteUse(cx_, name, parseContext_->scriptId(), parseContext_->innermostScope()->id()));
BINJS_TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
return result;
}
@@ -5652,52 +5124,43 @@ BinASTParser<Tok>::parseInterfaceIdentif
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseIfStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::IfStatement) {
+ return raiseInvalidKind("IfStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceIfStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceIfStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::IfStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Test, BinField::Consequent, BinField::Alternate };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(test, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(consequent, parseStatement());
-
-
-
BINJS_MOZ_TRY_DECL(alternate, parseOptionalStatement());
-
BINJS_TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate));
return result;
}
/*
interface Import : Node {
string moduleSpecifier;
@@ -5708,18 +5171,20 @@ BinASTParser<Tok>::parseInterfaceIfState
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseImport()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Import) {
+ return raiseInvalidKind("Import", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceImport(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceImport(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5738,18 +5203,20 @@ BinASTParser<Tok>::parseInterfaceImport(
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseImportNamespace()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ImportNamespace) {
+ return raiseInvalidKind("ImportNamespace", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceImportNamespace(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceImportNamespace(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5767,18 +5234,20 @@ BinASTParser<Tok>::parseInterfaceImportN
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseImportSpecifier()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ImportSpecifier) {
+ return raiseInvalidKind("ImportSpecifier", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceImportSpecifier(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceImportSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5796,49 +5265,44 @@ BinASTParser<Tok>::parseInterfaceImportS
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLabelledStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LabelledStatement) {
+ return raiseInvalidKind("LabelledStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLabelledStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLabelledStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LabelledStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Label, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom label(cx_);
MOZ_TRY_VAR(label, tokenizer_->readAtom());
if (!IsIdentifier(label))
return raiseError("Invalid identifier");
ParseContext::LabelStatement stmt(parseContext_, label);
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start));
return result;
}
/*
interface LiteralBooleanExpression : Node {
bool value;
@@ -5847,42 +5311,39 @@ BinASTParser<Tok>::parseInterfaceLabelle
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralBooleanExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralBooleanExpression) {
+ return raiseInvalidKind("LiteralBooleanExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Value };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(value, tokenizer_->readBool());
-
BINJS_TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start)));
return result;
}
/*
interface LiteralInfinityExpression : Node {
}
@@ -5890,18 +5351,20 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralInfinityExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralInfinityExpression) {
+ return raiseInvalidKind("LiteralInfinityExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralInfinityExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -5917,30 +5380,31 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralNullExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralNullExpression) {
+ return raiseInvalidKind("LiteralNullExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralNullExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralNullExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
MOZ_TRY(tokenizer_->checkFields0(kind, fields));
BINJS_TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start)));
return result;
}
/*
@@ -5951,42 +5415,39 @@ MOZ_TRY(tokenizer_->checkFields0(kind, f
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralNumericExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralNumericExpression) {
+ return raiseInvalidKind("LiteralNumericExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralNumericExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralNumericExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Value };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(value, tokenizer_->readDouble());
-
BINJS_TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start)));
return result;
}
/*
interface LiteralPropertyName : Node {
string value;
@@ -5995,42 +5456,40 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralPropertyName()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralPropertyName) {
+ return raiseInvalidKind("LiteralPropertyName", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralPropertyName(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralPropertyName);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Value };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom value(cx_);
MOZ_TRY_VAR(value, tokenizer_->readAtom());
-
ParseNode* result;
uint32_t index;
if (value->isIndex(&index))
BINJS_TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset())));
else
BINJS_TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start)));
return result;
}
@@ -6045,41 +5504,39 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralRegExpExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralRegExpExpression) {
+ return raiseInvalidKind("LiteralRegExpExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralRegExpExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralRegExpExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Pattern, BinField::Flags };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom pattern(cx_);
MOZ_TRY_VAR(pattern, tokenizer_->readAtom());
-
Chars flags(cx_);
MOZ_TRY(tokenizer_->readChars(flags));
RegExpFlag reflags = NoFlags;
for (auto c : flags) {
if (c == 'g' && !(reflags & GlobalFlag))
reflags = RegExpFlag(reflags | GlobalFlag);
else if (c == 'i' && !(reflags & IgnoreCaseFlag))
@@ -6115,42 +5572,40 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseLiteralStringExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::LiteralStringExpression) {
+ return raiseInvalidKind("LiteralStringExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceLiteralStringExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceLiteralStringExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::LiteralStringExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Value };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
RootedAtom value(cx_);
MOZ_TRY_VAR(value, tokenizer_->readAtom());
-
BINJS_TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start)));
return result;
}
/*
interface Module : Node {
AssertedVarScope? scope;
@@ -6161,18 +5616,20 @@ BinASTParser<Tok>::parseInterfaceLiteral
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseModule()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Module) {
+ return raiseInvalidKind("Module", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceModule(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceModule(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6190,47 +5647,41 @@ BinASTParser<Tok>::parseInterfaceModule(
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseNewExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::NewExpression) {
+ return raiseInvalidKind("NewExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceNewExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::NewExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Callee, BinField::Arguments };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(callee, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(arguments, parseArguments());
-
auto result = arguments;
result->setKind(ParseNodeKind::New);
result->prepend(callee);
result->setOp(JSOP_NEW);
return result;
}
@@ -6241,18 +5692,20 @@ BinASTParser<Tok>::parseInterfaceNewExpr
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseNewTargetExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::NewTargetExpression) {
+ return raiseInvalidKind("NewTargetExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceNewTargetExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceNewTargetExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6269,18 +5722,20 @@ BinASTParser<Tok>::parseInterfaceNewTarg
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseObjectAssignmentTarget()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ObjectAssignmentTarget) {
+ return raiseInvalidKind("ObjectAssignmentTarget", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceObjectAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6297,18 +5752,20 @@ BinASTParser<Tok>::parseInterfaceObjectA
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseObjectBinding()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ObjectBinding) {
+ return raiseInvalidKind("ObjectBinding", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectBinding(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceObjectBinding(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6325,42 +5782,39 @@ BinASTParser<Tok>::parseInterfaceObjectB
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseObjectExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ObjectExpression) {
+ return raiseInvalidKind("ObjectExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceObjectExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ObjectExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Properties };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(properties, parseListOfObjectProperty());
-
auto result = properties;
return result;
}
/*
interface ReturnStatement : Node {
Expression? expression;
@@ -6369,47 +5823,45 @@ BinASTParser<Tok>::parseInterfaceObjectE
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseReturnStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ReturnStatement) {
+ return raiseInvalidKind("ReturnStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceReturnStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceReturnStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ReturnStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
if (!parseContext_->isFunctionBox()) {
// Return statements are permitted only inside functions.
return raiseInvalidKind("Toplevel Statement", kind);
}
parseContext_->functionBox()->usesReturn = true;
-
BINJS_MOZ_TRY_DECL(expression, parseOptionalExpression());
-
BINJS_TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start)));
return result;
}
/*
interface Script : Node {
AssertedVarScope? scope;
@@ -6420,52 +5872,43 @@ BinASTParser<Tok>::parseInterfaceReturnS
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseScript()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Script) {
+ return raiseInvalidKind("Script", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceScript(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceScript(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::Script);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Scope, BinField::Directives, BinField::Statements };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
BINJS_MOZ_TRY_DECL(directives, parseListOfDirective());
-
-
-
BINJS_MOZ_TRY_DECL(statements, parseListOfStatement());
-
MOZ_TRY(checkClosedVars(parseContext_->varScope())); BINJS_MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));
return result;
}
/*
interface ShorthandProperty : Node {
IdentifierExpression name;
@@ -6474,42 +5917,39 @@ BinASTParser<Tok>::parseInterfaceScript(
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseShorthandProperty()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ShorthandProperty) {
+ return raiseInvalidKind("ShorthandProperty", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceShorthandProperty(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceShorthandProperty(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ShorthandProperty);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Name };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(name, parseIdentifierExpression());
-
if (!factory_.isUsableAsObjectPropertyName(name))
BINJS_TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start)));
BINJS_TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None));
return result;
}
@@ -6521,18 +5961,20 @@ BinASTParser<Tok>::parseInterfaceShortha
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableArrowExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableArrowExpression) {
+ return raiseInvalidKind("SkippableArrowExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableArrowExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableArrowExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6549,18 +5991,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableFunctionDeclaration()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableFunctionDeclaration) {
+ return raiseInvalidKind("SkippableFunctionDeclaration", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionDeclaration(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6577,18 +6021,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableFunctionExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableFunctionExpression) {
+ return raiseInvalidKind("SkippableFunctionExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableFunctionExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6605,18 +6051,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableGetter()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableGetter) {
+ return raiseInvalidKind("SkippableGetter", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableGetter(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableGetter(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6633,18 +6081,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableMethod()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableMethod) {
+ return raiseInvalidKind("SkippableMethod", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableMethod(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableMethod(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6661,18 +6111,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSkippableSetter()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SkippableSetter) {
+ return raiseInvalidKind("SkippableSetter", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSkippableSetter(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSkippableSetter(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6689,18 +6141,20 @@ BinASTParser<Tok>::parseInterfaceSkippab
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSpreadElement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SpreadElement) {
+ return raiseInvalidKind("SpreadElement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSpreadElement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSpreadElement(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6718,47 +6172,42 @@ BinASTParser<Tok>::parseInterfaceSpreadE
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseStaticMemberAssignmentTarget()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::StaticMemberAssignmentTarget) {
+ return raiseInvalidKind("StaticMemberAssignmentTarget", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::StaticMemberAssignmentTarget);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Object, BinField::Property };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper());
-
-
RootedAtom property(cx_);
MOZ_TRY_VAR(property, tokenizer_->readAtom());
-
BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));
return result;
}
/*
interface StaticMemberExpression : Node {
(Expression or Super) object;
@@ -6768,47 +6217,42 @@ BinASTParser<Tok>::parseInterfaceStaticM
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseStaticMemberExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::StaticMemberExpression) {
+ return raiseInvalidKind("StaticMemberExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceStaticMemberExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceStaticMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::StaticMemberExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Object, BinField::Property };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(object, parseExpressionOrSuper());
-
-
RootedAtom property(cx_);
MOZ_TRY_VAR(property, tokenizer_->readAtom());
-
BINJS_TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));
return result;
}
/*
interface Super : Node {
}
@@ -6816,18 +6260,20 @@ BinASTParser<Tok>::parseInterfaceStaticM
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSuper()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::Super) {
+ return raiseInvalidKind("Super", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSuper(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSuper(const size_t start, const BinKind kind, const BinFields& fields)
@@ -6845,47 +6291,41 @@ BinASTParser<Tok>::parseInterfaceSuper(c
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSwitchCase()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SwitchCase) {
+ return raiseInvalidKind("SwitchCase", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchCase(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSwitchCase(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::SwitchCase);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Test, BinField::Consequent };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(test, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(consequent, parseListOfStatement());
-
BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent));
return result;
}
/*
interface SwitchDefault : Node {
FrozenArray<Statement> consequent;
@@ -6894,42 +6334,39 @@ BinASTParser<Tok>::parseInterfaceSwitchC
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSwitchDefault()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SwitchDefault) {
+ return raiseInvalidKind("SwitchDefault", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchDefault(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSwitchDefault(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::SwitchDefault);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Consequent };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(consequent, parseListOfStatement());
-
BINJS_TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent));
return result;
}
/*
interface SwitchStatement : Node {
Expression discriminant;
@@ -6939,47 +6376,41 @@ BinASTParser<Tok>::parseInterfaceSwitchD
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSwitchStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SwitchStatement) {
+ return raiseInvalidKind("SwitchStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSwitchStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::SwitchStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Discriminant, BinField::Cases };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(discriminant, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(cases, parseListOfSwitchCase());
-
BINJS_TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases));
BINJS_TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope));
return result;
}
/*
interface SwitchStatementWithDefault : Node {
@@ -6992,57 +6423,45 @@ BinASTParser<Tok>::parseInterfaceSwitchS
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseSwitchStatementWithDefault()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::SwitchStatementWithDefault) {
+ return raiseInvalidKind("SwitchStatementWithDefault", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceSwitchStatementWithDefault(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::SwitchStatementWithDefault);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[4] = { BinField::Discriminant, BinField::PreDefaultCases, BinField::DefaultCase, BinField::PostDefaultCases };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(discriminant, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(preDefaultCases, parseListOfSwitchCase());
-
-
-
BINJS_MOZ_TRY_DECL(defaultCase, parseSwitchDefault());
-
-
-
BINJS_MOZ_TRY_DECL(postDefaultCases, parseListOfSwitchCase());
-
// Concatenate `preDefaultCase`, `defaultCase`, `postDefaultCase`
auto cases = preDefaultCases;
factory_.addList(cases, defaultCase);
ParseNode* iter = postDefaultCases->pn_head;
while (iter) {
ParseNode* next = iter->pn_next;
factory_.addList(cases, iter);
iter = next;
@@ -7061,18 +6480,20 @@ BinASTParser<Tok>::parseInterfaceSwitchS
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseTemplateElement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::TemplateElement) {
+ return raiseInvalidKind("TemplateElement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceTemplateElement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
@@ -7090,18 +6511,20 @@ BinASTParser<Tok>::parseInterfaceTemplat
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseTemplateExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::TemplateExpression) {
+ return raiseInvalidKind("TemplateExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceTemplateExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceTemplateExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -7117,30 +6540,31 @@ BinASTParser<Tok>::parseInterfaceTemplat
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseThisExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ThisExpression) {
+ return raiseInvalidKind("ThisExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceThisExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceThisExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ThisExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
MOZ_TRY(tokenizer_->checkFields0(kind, fields));
if (parseContext_->isFunctionBox())
parseContext_->functionBox()->usesThis = true;
TokenPos pos = tokenizer_->pos(start);
ParseNode* thisName(nullptr);
if (parseContext_->sc()->thisBinding() == ThisBinding::Function) {
@@ -7162,42 +6586,39 @@ MOZ_TRY(tokenizer_->checkFields0(kind, f
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseThrowStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::ThrowStatement) {
+ return raiseInvalidKind("ThrowStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceThrowStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceThrowStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::ThrowStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[1] = { BinField::Expression };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(expression, parseExpression());
-
BINJS_TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start)));
return result;
}
/*
interface TryCatchStatement : Node {
Block body;
@@ -7207,51 +6628,47 @@ BinASTParser<Tok>::parseInterfaceThrowSt
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseTryCatchStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::TryCatchStatement) {
+ return raiseInvalidKind("TryCatchStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceTryCatchStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceTryCatchStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::TryCatchStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Body, BinField::CatchClause };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
ParseNode* body;
{
ParseContext::Statement stmt(parseContext_, StatementKind::Try);
ParseContext::Scope scope(cx_, parseContext_, usedNames_);
BINJS_TRY(scope.init(parseContext_));
MOZ_TRY_VAR(body, parseBlock());
}
-
-
BINJS_MOZ_TRY_DECL(catchClause, parseCatchClause());
-
BINJS_TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr));
return result;
}
/*
interface TryFinallyStatement : Node {
Block body;
@@ -7262,51 +6679,46 @@ BinASTParser<Tok>::parseInterfaceTryCatc
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseTryFinallyStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::TryFinallyStatement) {
+ return raiseInvalidKind("TryFinallyStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceTryFinallyStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceTryFinallyStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::TryFinallyStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::Body, BinField::CatchClause, BinField::Finalizer };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
ParseNode* body;
{
ParseContext::Statement stmt(parseContext_, StatementKind::Try);
ParseContext::Scope scope(cx_, parseContext_, usedNames_);
BINJS_TRY(scope.init(parseContext_));
MOZ_TRY_VAR(body, parseBlock());
}
-
-
BINJS_MOZ_TRY_DECL(catchClause, parseOptionalCatchClause());
-
-
ParseNode* finalizer;
{
ParseContext::Statement stmt(parseContext_, StatementKind::Finally);
ParseContext::Scope scope(cx_, parseContext_, usedNames_);
BINJS_TRY(scope.init(parseContext_));
MOZ_TRY_VAR(finalizer, parseBlock());
}
@@ -7325,47 +6737,41 @@ BinASTParser<Tok>::parseInterfaceTryFina
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseUnaryExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::UnaryExpression) {
+ return raiseInvalidKind("UnaryExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceUnaryExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceUnaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::UnaryExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Operator, BinField::Operand };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(operator_, parseUnaryOperator());
-
-
-
BINJS_MOZ_TRY_DECL(operand, parseExpression());
-
ParseNodeKind pnk;
switch (operator_) {
case UnaryOperator::Minus:
pnk = ParseNodeKind::Neg;
break;
case UnaryOperator::Plus:
pnk = ParseNodeKind::Pos;
break;
@@ -7418,52 +6824,43 @@ BinASTParser<Tok>::parseInterfaceUnaryEx
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseUpdateExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::UpdateExpression) {
+ return raiseInvalidKind("UpdateExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceUpdateExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceUpdateExpression(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::UpdateExpression);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[3] = { BinField::IsPrefix, BinField::Operator, BinField::Operand };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(isPrefix, tokenizer_->readBool());
-
-
-
BINJS_MOZ_TRY_DECL(operator_, parseUpdateOperator());
-
-
-
BINJS_MOZ_TRY_DECL(operand, parseSimpleAssignmentTarget());
-
ParseNodeKind pnk;
switch (operator_) {
case UpdateOperator::Incr:
pnk = isPrefix ? ParseNodeKind::PreIncrement
: ParseNodeKind::PostIncrement;
break;
case UpdateOperator::Decr:
pnk = isPrefix ? ParseNodeKind::PreDecrement
@@ -7484,48 +6881,43 @@ BinASTParser<Tok>::parseInterfaceUpdateE
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseVariableDeclaration()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::VariableDeclaration) {
+ return raiseInvalidKind("VariableDeclaration", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceVariableDeclaration(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::VariableDeclaration);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Kind, BinField::Declarators };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
AutoVariableDeclarationKind kindGuard(this);
-
BINJS_MOZ_TRY_DECL(kind_, parseVariableDeclarationKind());
// Restored by `kindGuard`.
variableDeclarationKind_ = kind_;
-
-
-
BINJS_MOZ_TRY_DECL(declarators, parseListOfVariableDeclarator());
-
// By specification, the list may not be empty.
if (declarators->pn_count == 0)
return raiseEmpty("VariableDeclaration");
ParseNodeKind pnk;
switch (kind_) {
case VariableDeclarationKind::Var:
pnk = ParseNodeKind::Var;
@@ -7552,47 +6944,41 @@ BinASTParser<Tok>::parseInterfaceVariabl
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseVariableDeclarator()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::VariableDeclarator) {
+ return raiseInvalidKind("VariableDeclarator", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceVariableDeclarator(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceVariableDeclarator(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::VariableDeclarator);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Binding, BinField::Init };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(binding, parseBinding());
-
-
-
BINJS_MOZ_TRY_DECL(init, parseOptionalExpression());
-
ParseNode* result;
if (binding->isKind(ParseNodeKind::Name)) {
// `var foo [= bar]``
MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName()));
BINJS_TRY_VAR(result, factory_.newName(binding->pn_atom->asPropertyName(), tokenizer_->pos(start), cx_));
if (init)
result->pn_expr = init;
@@ -7619,47 +7005,42 @@ BinASTParser<Tok>::parseInterfaceVariabl
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseWhileStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::WhileStatement) {
+ return raiseInvalidKind("WhileStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceWhileStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::WhileStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Test, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
ParseContext::Statement stmt(parseContext_, StatementKind::WhileLoop);
-
BINJS_MOZ_TRY_DECL(test, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(result, factory_.newWhileStatement(start, test, body));
return result;
}
/*
interface WithStatement : Node {
Expression object;
@@ -7669,47 +7050,41 @@ BinASTParser<Tok>::parseInterfaceWhileSt
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseWithStatement()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::WithStatement) {
+ return raiseInvalidKind("WithStatement", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceWithStatement(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceWithStatement(const size_t start, const BinKind kind, const BinFields& fields)
{
MOZ_ASSERT(kind == BinKind::WithStatement);
BINJS_TRY(CheckRecursionLimit(cx_));
-
#if defined(DEBUG)
const BinField expected_fields[2] = { BinField::Object, BinField::Body };
MOZ_TRY(tokenizer_->checkFields(kind, fields, expected_fields));
#endif // defined(DEBUG)
-
-
-
BINJS_MOZ_TRY_DECL(object, parseExpression());
-
-
-
BINJS_MOZ_TRY_DECL(body, parseStatement());
-
BINJS_TRY_DECL(result, factory_.newWithStatement(start, object, body));
return result;
}
/*
interface YieldExpression : Node {
Expression? expression;
@@ -7718,18 +7093,20 @@ BinASTParser<Tok>::parseInterfaceWithSta
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseYieldExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::YieldExpression) {
+ return raiseInvalidKind("YieldExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceYieldExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceYieldExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -7746,18 +7123,20 @@ BinASTParser<Tok>::parseInterfaceYieldEx
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseYieldStarExpression()
{
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
- const auto start = tokenizer_->offset();
-
+ if (kind != BinKind::YieldStarExpression) {
+ return raiseInvalidKind("YieldStarExpression", kind);
+ }
+ const auto start = tokenizer_->offset();
BINJS_MOZ_TRY_DECL(result, parseInterfaceYieldStarExpression(start, kind, fields));
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseInterfaceYieldStarExpression(const size_t start, const BinKind kind, const BinFields& fields)
@@ -8224,19 +7603,21 @@ BinASTParser<Tok>::parseOptionalAsserted
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
Ok result;
if (kind == BinKind::_Null) {
result = Ok();
- } else {
+ } else if (kind == BinKind::AssertedBlockScope) {
const auto start = tokenizer_->offset();
MOZ_TRY_VAR(result, parseInterfaceAssertedBlockScope(start, kind, fields));
+ } else {
+ return raiseInvalidKind("AssertedBlockScope", kind);
}
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseOptionalAssertedParameterScope()
@@ -8244,19 +7625,21 @@ BinASTParser<Tok>::parseOptionalAsserted
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
Ok result;
if (kind == BinKind::_Null) {
result = Ok();
- } else {
+ } else if (kind == BinKind::AssertedParameterScope) {
const auto start = tokenizer_->offset();
MOZ_TRY_VAR(result, parseInterfaceAssertedParameterScope(start, kind, fields));
+ } else {
+ return raiseInvalidKind("AssertedParameterScope", kind);
}
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<Ok>
BinASTParser<Tok>::parseOptionalAssertedVarScope()
@@ -8264,19 +7647,21 @@ BinASTParser<Tok>::parseOptionalAsserted
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
Ok result;
if (kind == BinKind::_Null) {
result = Ok();
- } else {
+ } else if (kind == BinKind::AssertedVarScope) {
const auto start = tokenizer_->offset();
MOZ_TRY_VAR(result, parseInterfaceAssertedVarScope(start, kind, fields));
+ } else {
+ return raiseInvalidKind("AssertedVarScope", kind);
}
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseOptionalAssignmentTarget()
@@ -8324,19 +7709,21 @@ BinASTParser<Tok>::parseOptionalBindingI
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
ParseNode* result;
if (kind == BinKind::_Null) {
result = nullptr;
- } else {
+ } else if (kind == BinKind::BindingIdentifier) {
const auto start = tokenizer_->offset();
MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields));
+ } else {
+ return raiseInvalidKind("BindingIdentifier", kind);
}
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseOptionalBindingOrBindingWithInitializer()
@@ -8364,19 +7751,21 @@ BinASTParser<Tok>::parseOptionalCatchCla
BinKind kind;
BinFields fields(cx_);
AutoTaggedTuple guard(*tokenizer_);
MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
ParseNode* result;
if (kind == BinKind::_Null) {
result = nullptr;
- } else {
+ } else if (kind == BinKind::CatchClause) {
const auto start = tokenizer_->offset();
MOZ_TRY_VAR(result, parseInterfaceCatchClause(start, kind, fields));
+ } else {
+ return raiseInvalidKind("CatchClause", kind);
}
MOZ_TRY(guard.done());
return result;
}
template<typename Tok> JS::Result<ParseNode*>
BinASTParser<Tok>::parseOptionalExpression()