Bug 1454744 - Part 2: Add bindings for formal parameter names. (r=Yoric)
authorEric Faust <efaustbmo@gmail.com>
Mon, 30 Apr 2018 20:46:14 -0700
changeset 472508 02e7d188fd568150be6629adf95a06363dfd6560
parent 472507 42c4d4acfba5d5c07e9f95c61c737b626d37c994
child 472509 80f9a47393edf19de2941b295b315df7ac0110b6
push id1728
push userjlund@mozilla.com
push dateMon, 18 Jun 2018 21:12:27 +0000
treeherdermozilla-release@c296fde26f5f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersYoric
bugs1454744
milestone61.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1454744 - Part 2: Add bindings for formal parameter names. (r=Yoric)
js/src/frontend/BinSource-auto.cpp
js/src/frontend/BinSource.yaml
--- a/js/src/frontend/BinSource-auto.cpp
+++ b/js/src/frontend/BinSource-auto.cpp
@@ -63,19 +63,21 @@ BinASTParser<Tok>::parseArrowExpression(
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumArrowExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -103,28 +105,33 @@ BinASTParser<Tok>::parseAssignmentTarget
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -153,31 +160,37 @@ BinASTParser<Tok>::parseAssignmentTarget
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -202,19 +215,21 @@ BinASTParser<Tok>::parseAssignmentTarget
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -239,19 +254,21 @@ BinASTParser<Tok>::parseAssignmentTarget
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -277,22 +294,25 @@ BinASTParser<Tok>::parseBinding()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -319,25 +339,29 @@ BinASTParser<Tok>::parseBindingOrBinding
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -362,19 +386,21 @@ BinASTParser<Tok>::parseBindingPattern()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -399,19 +425,21 @@ BinASTParser<Tok>::parseBindingProperty(
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -439,28 +467,33 @@ BinASTParser<Tok>::parseExportDeclaratio
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -513,103 +546,133 @@ BinASTParser<Tok>::parseExpression()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -663,106 +726,137 @@ BinASTParser<Tok>::parseExpressionOrSupe
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -816,106 +910,137 @@ BinASTParser<Tok>::parseExpressionOrTemp
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -944,31 +1069,37 @@ BinASTParser<Tok>::parseForInOfBindingOr
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1022,106 +1153,137 @@ BinASTParser<Tok>::parseFunctionBodyOrEx
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1146,19 +1308,21 @@ BinASTParser<Tok>::parseFunctionDeclarat
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1214,112 +1378,145 @@ BinASTParser<Tok>::parseFunctionDeclarat
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1346,25 +1543,29 @@ BinASTParser<Tok>::parseFunctionDeclarat
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1389,19 +1590,21 @@ BinASTParser<Tok>::parseFunctionExpressi
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1426,19 +1629,21 @@ BinASTParser<Tok>::parseGetter()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumGetter(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1463,19 +1668,21 @@ BinASTParser<Tok>::parseImportDeclaratio
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1529,106 +1736,137 @@ BinASTParser<Tok>::parseImportDeclaratio
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1656,28 +1894,33 @@ BinASTParser<Tok>::parseIterationStateme
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1705,28 +1948,33 @@ BinASTParser<Tok>::parseLiteral()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1751,19 +1999,21 @@ BinASTParser<Tok>::parseMethod()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumMethod(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1792,31 +2042,37 @@ BinASTParser<Tok>::parseMethodDefinition
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1847,37 +2103,45 @@ BinASTParser<Tok>::parseObjectProperty()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1904,25 +2168,29 @@ BinASTParser<Tok>::parseParameter()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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));
+        BINJS_TRY(parseContext_->positionalFormalParameterNames().append(result->pn_atom));
         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;
 }
 
 /*
@@ -1947,19 +2215,21 @@ BinASTParser<Tok>::parseProgram()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -1984,19 +2254,21 @@ BinASTParser<Tok>::parsePropertyName()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -2021,19 +2293,21 @@ BinASTParser<Tok>::parseSetter()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumSetter(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -2059,22 +2333,25 @@ BinASTParser<Tok>::parseSimpleAssignment
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -2128,106 +2405,137 @@ BinASTParser<Tok>::parseSpreadElementOrE
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -2274,85 +2582,109 @@ BinASTParser<Tok>::parseStatement()
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 /*
@@ -2406,106 +2738,137 @@ BinASTParser<Tok>::parseVariableDeclarat
 
 template<typename Tok> JS::Result<ParseNode*>
 BinASTParser<Tok>::parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     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;
 }
 
 
--- a/js/src/frontend/BinSource.yaml
+++ b/js/src/frontend/BinSource.yaml
@@ -829,16 +829,22 @@ OptionalAssertedBlockScope:
 OptionalAssertedVarScope:
     type-ok:
         Ok
 
 OptionalAssertedParameterScope:
     type-ok:
         Ok
 
+Parameter:
+    sum-arms:
+        BindingIdentifier:
+            after:
+                BINJS_TRY(parseContext_->positionalFormalParameterNames().append(result->pn_atom));
+
 ReturnStatement:
     init: |
         if (!parseContext_->isFunctionBox()) {
             // Return statements are permitted only inside functions.
             return raiseInvalidKind("Toplevel Statement", kind);
         }
 
         parseContext_->functionBox()->usesReturn = true;