--- a/js/src/frontend/BinSource-auto.cpp
+++ b/js/src/frontend/BinSource-auto.cpp
@@ -12,158 +12,102 @@
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Casting.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/Move.h"
 #include "mozilla/PodOperations.h"
 #include "mozilla/Vector.h"
 
 #include "frontend/BinSource.h"
+#include "frontend/BinSource-macros.h"
 #include "frontend/BinTokenReaderTester.h"
 #include "frontend/FullParseHandler.h"
 #include "frontend/Parser.h"
 #include "frontend/SharedContext.h"
 
 #include "vm/RegExpObject.h"
 
 #include "frontend/ParseContext-inl.h"
 #include "frontend/ParseNode-inl.h"
 
 namespace js {
 namespace frontend {
 
-using AutoList = BinTokenReaderTester::AutoList;
-using AutoTaggedTuple = BinTokenReaderTester::AutoTaggedTuple;
-using AutoTuple = BinTokenReaderTester::AutoTuple;
-using BinFields = BinTokenReaderTester::BinFields;
-using Chars = BinTokenReaderTester::Chars;
-using NameBag = GCHashSet<JSString*>;
-using Names = GCVector<JSString*, 8>;
-using UsedNamePtr = UsedNameTracker::UsedNameMap::Ptr;
-
-// Evaluate an expression EXPR, checking that the result is not falsy.
-//
-// Throw `cx->alreadyReportedError()` if it returns 0/nullptr.
-#define TRY(EXPR) \
-    do { \
-        if (!EXPR) \
-            return cx_->alreadyReportedError(); \
-    } while(false)
-
-
-// Evaluate an expression EXPR, checking that the result is not falsy.
-// In case of success, assign the result to VAR.
-//
-// Throw `cx->alreadyReportedError()` if it returns 0/nullptr.
-#define TRY_VAR(VAR, EXPR) \
-    do { \
-        VAR = EXPR; \
-        if (!VAR) \
-            return cx_->alreadyReportedError(); \
-    } while (false)
-
-// Evaluate an expression EXPR, checking that the result is not falsy.
-// In case of success, assign the result to a new variable VAR.
-//
-// Throw `cx->alreadyReportedError()` if it returns 0/nullptr.
-#define TRY_DECL(VAR, EXPR) \
-    auto VAR = EXPR; \
-    if (!VAR) \
-        return cx_->alreadyReportedError();
-
-// Evaluate an expression EXPR, checking that the result is a success.
-// In case of success, unwrap and assign the result to a new variable VAR.
-//
-// In case of error, propagate the error.
-#define MOZ_TRY_DECL(VAR, EXPR) \
-    auto _##VAR = EXPR; \
-    if (_##VAR.isErr()) \
-        return ::mozilla::Err(_##VAR.unwrapErr()); \
-    auto VAR = _##VAR.unwrap();
-
-// Ensure that we are visiting the right fields.
-template<size_t N>
-JS::Result<Ok, JS::Error&>
-BinASTParser::checkFields(const BinKind kind, const BinFields& actual, const BinField (&expected)[N])
-{
-    if (actual.length() != N)
-        return raiseInvalidNumberOfFields(kind, N, actual.length());
-
-    for (size_t i = 0; i < N; ++i) {
-        if (actual[i] != expected[i])
-            return raiseInvalidField(describeBinKind(kind), actual[i]);
-    }
-
-    return Ok();
-}
-
-// Special case for N=0, as empty arrays are not permitted in C++
-JS::Result<Ok, JS::Error&>
-BinASTParser::checkFields0(const BinKind kind, const BinFields& actual)
-{
-    if (actual.length() != 0)
-        return raiseInvalidNumberOfFields(kind, 0, actual.length());
-
-    return Ok();
-}
-
 // Compare a bunch of `uint8_t` values (as returned by the tokenizer_) with
 // a string literal (and ONLY a string literal).
-template<size_t N>
-bool operator==(const Chars& left, const char (&right)[N]) {
-    return BinTokenReaderTester::equals(left, right);
-}
-
-// Helper class: Restore field `variableDeclarationKind_` upon leaving a scope.
-class MOZ_RAII AutoVariableDeclarationKind {
-  public:
-    explicit AutoVariableDeclarationKind(BinASTParser* parser
-                                         MOZ_GUARD_OBJECT_NOTIFIER_PARAM) :
-      parser_(parser),
-      kind(parser->variableDeclarationKind_)
-    {
-        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-    }
-    ~AutoVariableDeclarationKind() {
-        parser_->variableDeclarationKind_ = kind;
-    }
-  private:
-    BinASTParser* parser_;
-    BinASTParser::VariableDeclarationKind kind;
-    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
-};
+template<typename Tok, size_t N>
+bool operator==(const typename Tok::Chars& left, const char (&right)[N]) {
+    return Tok::equals(left, right);
+}
 
 
 // ----- Sums of interfaces (autogenerated, by lexicographical order)
 // Sums of sums are flattened.
 /*
+ArrowExpression ::= EagerArrowExpression
+    SkippableArrowExpression
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseArrowExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumArrowExpression(start, kind, fields));
+
+    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) {
+      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;
+}
+
+/*
 AssignmentTarget ::= ArrayAssignmentTarget
     AssignmentTargetIdentifier
     ComputedMemberAssignmentTarget
     ObjectAssignmentTarget
     StaticMemberAssignmentTarget
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseAssignmentTarget()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumAssignmentTarget(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -186,34 +130,34 @@ BinASTParser::parseSumAssignmentTarget(c
 /*
 AssignmentTargetOrAssignmentTargetWithInitializer ::= ArrayAssignmentTarget
     AssignmentTargetIdentifier
     AssignmentTargetWithInitializer
     ComputedMemberAssignmentTarget
     ObjectAssignmentTarget
     StaticMemberAssignmentTarget
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetOrAssignmentTargetWithInitializer()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseAssignmentTargetOrAssignmentTargetWithInitializer()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumAssignmentTargetOrAssignmentTargetWithInitializer(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumAssignmentTargetOrAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -235,34 +179,34 @@ BinASTParser::parseSumAssignmentTargetOr
     }
     return result;
 }
 
 /*
 AssignmentTargetPattern ::= ArrayAssignmentTarget
     ObjectAssignmentTarget
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetPattern()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseAssignmentTargetPattern()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumAssignmentTargetPattern(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumAssignmentTargetPattern(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -272,34 +216,34 @@ BinASTParser::parseSumAssignmentTargetPa
     }
     return result;
 }
 
 /*
 AssignmentTargetProperty ::= AssignmentTargetPropertyIdentifier
     AssignmentTargetPropertyProperty
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseAssignmentTargetProperty()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumAssignmentTargetProperty(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumAssignmentTargetProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -310,34 +254,34 @@ BinASTParser::parseSumAssignmentTargetPr
     return result;
 }
 
 /*
 Binding ::= ArrayBinding
     BindingIdentifier
     ObjectBinding
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBinding()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseBinding()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumBinding(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumBinding(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -352,34 +296,34 @@ BinASTParser::parseSumBinding(const size
 }
 
 /*
 BindingOrBindingWithInitializer ::= ArrayBinding
     BindingIdentifier
     BindingWithInitializer
     ObjectBinding
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingOrBindingWithInitializer()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseBindingOrBindingWithInitializer()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumBindingOrBindingWithInitializer(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumBindingOrBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -395,34 +339,34 @@ BinASTParser::parseSumBindingOrBindingWi
     }
     return result;
 }
 
 /*
 BindingPattern ::= ArrayBinding
     ObjectBinding
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingPattern()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseBindingPattern()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumBindingPattern(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumBindingPattern(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -432,34 +376,34 @@ BinASTParser::parseSumBindingPattern(con
     }
     return result;
 }
 
 /*
 BindingProperty ::= BindingPropertyIdentifier
     BindingPropertyProperty
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseBindingProperty()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumBindingProperty(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumBindingProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -472,34 +416,34 @@ BinASTParser::parseSumBindingProperty(co
 
 /*
 ExportDeclaration ::= Export
     ExportAllFrom
     ExportDefault
     ExportFrom
     ExportLocals
 */
-JS::Result<ParseNode*>
-BinASTParser::parseExportDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseExportDeclaration()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumExportDeclaration(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumExportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -516,71 +460,70 @@ BinASTParser::parseSumExportDeclaration(
       default:
         return raiseInvalidKind("ExportDeclaration", kind);
     }
     return result;
 }
 
 /*
 Expression ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     StaticMemberExpression
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumExpression(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -595,18 +538,21 @@ BinASTParser::parseSumExpression(const s
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -628,16 +574,22 @@ BinASTParser::parseSumExpression(const s
         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));
@@ -657,72 +609,71 @@ BinASTParser::parseSumExpression(const s
       default:
         return raiseInvalidKind("Expression", kind);
     }
     return result;
 }
 
 /*
 ExpressionOrSuper ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     StaticMemberExpression
     Super
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseExpressionOrSuper()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseExpressionOrSuper()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumExpressionOrSuper(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumExpressionOrSuper(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -737,18 +688,21 @@ BinASTParser::parseSumExpressionOrSuper(
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -770,16 +724,22 @@ BinASTParser::parseSumExpressionOrSuper(
         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));
@@ -802,72 +762,71 @@ BinASTParser::parseSumExpressionOrSuper(
       default:
         return raiseInvalidKind("ExpressionOrSuper", kind);
     }
     return result;
 }
 
 /*
 ExpressionOrTemplateElement ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     StaticMemberExpression
     TemplateElement
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseExpressionOrTemplateElement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseExpressionOrTemplateElement()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumExpressionOrTemplateElement(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumExpressionOrTemplateElement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -882,18 +841,21 @@ BinASTParser::parseSumExpressionOrTempla
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -915,16 +877,22 @@ BinASTParser::parseSumExpressionOrTempla
         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));
@@ -953,34 +921,34 @@ BinASTParser::parseSumExpressionOrTempla
 /*
 ForInOfBindingOrAssignmentTarget ::= ArrayAssignmentTarget
     AssignmentTargetIdentifier
     ComputedMemberAssignmentTarget
     ForInOfBinding
     ObjectAssignmentTarget
     StaticMemberAssignmentTarget
 */
-JS::Result<ParseNode*>
-BinASTParser::parseForInOfBindingOrAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseForInOfBindingOrAssignmentTarget()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumForInOfBindingOrAssignmentTarget(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumForInOfBindingOrAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1000,72 +968,71 @@ BinASTParser::parseSumForInOfBindingOrAs
       default:
         return raiseInvalidKind("ForInOfBindingOrAssignmentTarget", kind);
     }
     return result;
 }
 
 /*
 FunctionBodyOrExpression ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     FunctionBody
-    FunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     StaticMemberExpression
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionBodyOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseFunctionBodyOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumFunctionBodyOrExpression(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumFunctionBodyOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -1080,22 +1047,25 @@ BinASTParser::parseSumFunctionBodyOrExpr
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(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));
@@ -1116,16 +1086,22 @@ BinASTParser::parseSumFunctionBodyOrExpr
         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));
@@ -1144,74 +1120,111 @@ BinASTParser::parseSumFunctionBodyOrExpr
         break;
       default:
         return raiseInvalidKind("FunctionBodyOrExpression", kind);
     }
     return result;
 }
 
 /*
+FunctionDeclaration ::= EagerFunctionDeclaration
+    SkippableFunctionDeclaration
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseFunctionDeclaration()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumFunctionDeclaration(start, kind, fields));
+
+    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) {
+      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;
+}
+
+/*
 FunctionDeclarationOrClassDeclarationOrExpression ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassDeclaration
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionDeclaration
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionDeclaration
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionDeclaration
+    SkippableFunctionExpression
     StaticMemberExpression
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionDeclarationOrClassDeclarationOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseFunctionDeclarationOrClassDeclarationOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrExpression(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -1229,21 +1242,24 @@ BinASTParser::parseSumFunctionDeclaratio
         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::FunctionDeclaration:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionDeclaration(start, kind, fields));
-        break;
-      case BinKind::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -1265,16 +1281,25 @@ BinASTParser::parseSumFunctionDeclaratio
         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));
@@ -1294,77 +1319,155 @@ BinASTParser::parseSumFunctionDeclaratio
       default:
         return raiseInvalidKind("FunctionDeclarationOrClassDeclarationOrExpression", kind);
     }
     return result;
 }
 
 /*
 FunctionDeclarationOrClassDeclarationOrVariableDeclaration ::= ClassDeclaration
-    FunctionDeclaration
+    EagerFunctionDeclaration
+    SkippableFunctionDeclaration
     VariableDeclaration
 */
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionDeclarationOrClassDeclarationOrVariableDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseFunctionDeclarationOrClassDeclarationOrVariableDeclaration()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumFunctionDeclarationOrClassDeclarationOrVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ClassDeclaration:
         MOZ_TRY_VAR(result, parseInterfaceClassDeclaration(start, kind, fields));
         break;
-      case BinKind::FunctionDeclaration:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionDeclaration(start, kind, fields));
+      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;
 }
 
 /*
+FunctionExpression ::= EagerFunctionExpression
+    SkippableFunctionExpression
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseFunctionExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumFunctionExpression(start, kind, fields));
+
+    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) {
+      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;
+}
+
+/*
+Getter ::= EagerGetter
+    SkippableGetter
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseGetter()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumGetter(start, kind, fields));
+
+    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) {
+      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;
+}
+
+/*
 ImportDeclaration ::= Import
     ImportNamespace
 */
-JS::Result<ParseNode*>
-BinASTParser::parseImportDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseImportDeclaration()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumImportDeclaration(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumImportDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1377,59 +1480,60 @@ BinASTParser::parseSumImportDeclaration(
 
 /*
 ImportDeclarationOrExportDeclarationOrStatement ::= Block
     BreakStatement
     ClassDeclaration
     ContinueStatement
     DebuggerStatement
     DoWhileStatement
+    EagerFunctionDeclaration
     EmptyStatement
     Export
     ExportAllFrom
     ExportDefault
     ExportFrom
     ExportLocals
     ExpressionStatement
     ForInStatement
     ForOfStatement
     ForStatement
-    FunctionDeclaration
     IfStatement
     Import
     ImportNamespace
     LabelledStatement
     ReturnStatement
+    SkippableFunctionDeclaration
     SwitchStatement
     SwitchStatementWithDefault
     ThrowStatement
     TryCatchStatement
     TryFinallyStatement
     VariableDeclaration
     WhileStatement
     WithStatement
 */
-JS::Result<ParseNode*>
-BinASTParser::parseImportDeclarationOrExportDeclarationOrStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseImportDeclarationOrExportDeclarationOrStatement()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumImportDeclarationOrExportDeclarationOrStatement(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumImportDeclarationOrExportDeclarationOrStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1441,16 +1545,19 @@ BinASTParser::parseSumImportDeclarationO
         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));
@@ -1471,34 +1578,34 @@ BinASTParser::parseSumImportDeclarationO
         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::FunctionDeclaration:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionDeclaration(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));
@@ -1526,34 +1633,34 @@ BinASTParser::parseSumImportDeclarationO
 
 /*
 IterationStatement ::= DoWhileStatement
     ForInStatement
     ForOfStatement
     ForStatement
     WhileStatement
 */
-JS::Result<ParseNode*>
-BinASTParser::parseIterationStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseIterationStatement()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumIterationStatement(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumIterationStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1575,34 +1682,34 @@ BinASTParser::parseSumIterationStatement
 
 /*
 Literal ::= LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralStringExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseLiteral()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseLiteral()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumLiteral(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumLiteral(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1618,129 +1725,190 @@ BinASTParser::parseSumLiteral(const size
         break;
       default:
         return raiseInvalidKind("Literal", kind);
     }
     return result;
 }
 
 /*
-MethodDefinition ::= Getter
-    Method
-    Setter
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseMethodDefinition()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-
-    MOZ_TRY_DECL(result, parseSumMethodDefinition(start, kind, fields));
-
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumMethodDefinition(const size_t start, const BinKind kind, const BinFields& fields)
+Method ::= EagerMethod
+    SkippableMethod
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseMethod()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumMethod(start, kind, fields));
+
+    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) {
-      case BinKind::Getter:
-        MOZ_TRY_VAR(result, parseInterfaceGetter(start, kind, fields));
-        break;
-      case BinKind::Method:
-        MOZ_TRY_VAR(result, parseInterfaceMethod(start, kind, fields));
-        break;
-      case BinKind::Setter:
-        MOZ_TRY_VAR(result, parseInterfaceSetter(start, kind, fields));
+      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;
+}
+
+/*
+MethodDefinition ::= EagerGetter
+    EagerMethod
+    EagerSetter
+    SkippableGetter
+    SkippableMethod
+    SkippableSetter
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseMethodDefinition()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumMethodDefinition(start, kind, fields));
+
+    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) {
+      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;
 }
 
 /*
 ObjectProperty ::= DataProperty
-    Getter
-    Method
-    Setter
+    EagerGetter
+    EagerMethod
+    EagerSetter
     ShorthandProperty
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseObjectProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    SkippableGetter
+    SkippableMethod
+    SkippableSetter
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseObjectProperty()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumObjectProperty(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumObjectProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::DataProperty:
         MOZ_TRY_VAR(result, parseInterfaceDataProperty(start, kind, fields));
         break;
-      case BinKind::Getter:
-        MOZ_TRY_VAR(result, parseInterfaceGetter(start, kind, fields));
-        break;
-      case BinKind::Method:
-        MOZ_TRY_VAR(result, parseInterfaceMethod(start, kind, fields));
-        break;
-      case BinKind::Setter:
-        MOZ_TRY_VAR(result, parseInterfaceSetter(start, kind, fields));
+      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;
 }
 
 /*
 Parameter ::= ArrayBinding
     BindingIdentifier
     BindingWithInitializer
     ObjectBinding
 */
-JS::Result<ParseNode*>
-BinASTParser::parseParameter()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseParameter()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumParameter(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumParameter(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1756,34 +1924,34 @@ BinASTParser::parseSumParameter(const si
     }
     return result;
 }
 
 /*
 Program ::= Module
     Script
 */
-JS::Result<ParseNode*>
-BinASTParser::parseProgram()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseProgram()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumProgram(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumProgram(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1793,72 +1961,109 @@ BinASTParser::parseSumProgram(const size
     }
     return result;
 }
 
 /*
 PropertyName ::= ComputedPropertyName
     LiteralPropertyName
 */
-JS::Result<ParseNode*>
-BinASTParser::parsePropertyName()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parsePropertyName()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumPropertyName(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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;
 }
 
 /*
+Setter ::= EagerSetter
+    SkippableSetter
+*/
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSetter()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+
+    MOZ_TRY_DECL(result, parseSumSetter(start, kind, fields));
+
+    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) {
+      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;
+}
+
+/*
 SimpleAssignmentTarget ::= AssignmentTargetIdentifier
     ComputedMemberAssignmentTarget
     StaticMemberAssignmentTarget
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSimpleAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSimpleAssignmentTarget()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumSimpleAssignmentTarget(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumSimpleAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -1869,72 +2074,71 @@ BinASTParser::parseSumSimpleAssignmentTa
       default:
         return raiseInvalidKind("SimpleAssignmentTarget", kind);
     }
     return result;
 }
 
 /*
 SpreadElementOrExpression ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     SpreadElement
     StaticMemberExpression
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSpreadElementOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSpreadElementOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumSpreadElementOrExpression(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumSpreadElementOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -1949,18 +2153,21 @@ BinASTParser::parseSumSpreadElementOrExp
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -1982,16 +2189,22 @@ BinASTParser::parseSumSpreadElementOrExp
         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));
@@ -2019,52 +2232,53 @@ BinASTParser::parseSumSpreadElementOrExp
 
 /*
 Statement ::= Block
     BreakStatement
     ClassDeclaration
     ContinueStatement
     DebuggerStatement
     DoWhileStatement
+    EagerFunctionDeclaration
     EmptyStatement
     ExpressionStatement
     ForInStatement
     ForOfStatement
     ForStatement
-    FunctionDeclaration
     IfStatement
     LabelledStatement
     ReturnStatement
+    SkippableFunctionDeclaration
     SwitchStatement
     SwitchStatementWithDefault
     ThrowStatement
     TryCatchStatement
     TryFinallyStatement
     VariableDeclaration
     WhileStatement
     WithStatement
 */
-JS::Result<ParseNode*>
-BinASTParser::parseStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseStatement()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumStatement(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     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));
@@ -2076,43 +2290,46 @@ BinASTParser::parseSumStatement(const si
         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::FunctionDeclaration:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionDeclaration(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));
@@ -2135,72 +2352,71 @@ BinASTParser::parseSumStatement(const si
       default:
         return raiseInvalidKind("Statement", kind);
     }
     return result;
 }
 
 /*
 VariableDeclarationOrExpression ::= ArrayExpression
-    ArrowExpression
     AssignmentExpression
     AwaitExpression
     BinaryExpression
     CallExpression
     ClassExpression
     CompoundAssignmentExpression
     ComputedMemberExpression
     ConditionalExpression
-    FunctionExpression
+    EagerArrowExpression
+    EagerFunctionExpression
     IdentifierExpression
     LiteralBooleanExpression
     LiteralInfinityExpression
     LiteralNullExpression
     LiteralNumericExpression
     LiteralRegExpExpression
     LiteralStringExpression
     NewExpression
     NewTargetExpression
     ObjectExpression
+    SkippableArrowExpression
+    SkippableFunctionExpression
     StaticMemberExpression
     TemplateExpression
     ThisExpression
     UnaryExpression
     UpdateExpression
     VariableDeclaration
     YieldExpression
     YieldStarExpression
 */
-JS::Result<ParseNode*>
-BinASTParser::parseVariableDeclarationOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-    const auto start = tokenizer_->offset();
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseVariableDeclarationOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+    const auto start = tokenizer_->offset();
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
 
     MOZ_TRY_DECL(result, parseSumVariableDeclarationOrExpression(start, kind, fields));
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseSumVariableDeclarationOrExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     ParseNode* result;
     switch(kind) {
       case BinKind::ArrayExpression:
         MOZ_TRY_VAR(result, parseInterfaceArrayExpression(start, kind, fields));
         break;
-      case BinKind::ArrowExpression:
-        MOZ_TRY_VAR(result, parseInterfaceArrowExpression(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));
@@ -2215,18 +2431,21 @@ BinASTParser::parseSumVariableDeclaratio
         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::FunctionExpression:
-        MOZ_TRY_VAR(result, parseInterfaceFunctionExpression(start, kind, fields));
+      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:
@@ -2248,16 +2467,22 @@ BinASTParser::parseSumVariableDeclaratio
         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));
@@ -2284,524 +2509,525 @@ BinASTParser::parseSumVariableDeclaratio
 }
 
 
 
 // ----- Interfaces (autogenerated, by lexicographical order)
 // When fields have a non-trivial type, implementation is deanonymized and delegated to another parser.
 
 /*
+ interface  : Node {
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (Null)");
+}
+
+
+/*
  interface ArrayAssignmentTarget : Node {
     FrozenArray<(AssignmentTarget or AssignmentTargetWithInitializer)> elements;
     AssignmentTarget? rest;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseArrayAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceArrayAssignmentTarget(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceArrayAssignmentTarget(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ArrayAssignmentTarget)");
 }
 
 
 /*
  interface ArrayBinding : Node {
     FrozenArray<(Binding or BindingWithInitializer)?> elements;
     Binding? rest;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseArrayBinding()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceArrayBinding(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceArrayBinding(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ArrayBinding)");
 }
 
 
 /*
  interface ArrayExpression : Node {
     FrozenArray<(SpreadElement or Expression)?> elements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseArrayExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceArrayExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceArrayExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ArrayExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Elements }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Elements }));
 
 
 
     MOZ_TRY_DECL(elements, parseListOfOptionalSpreadElementOrExpression());
 
 
-    auto result = elements;return result;
-}
-
-
-/*
- interface ArrowExpression : Node {
-    bool isAsync;
-    AssertedParameterScope? parameterScope;
-    AssertedVarScope? bodyScope;
-    FormalParameters params;
-    (FunctionBody or Expression) body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseArrowExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceArrowExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceArrowExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ArrowExpression)");
+    auto result = elements;
+    return result;
 }
 
 
 /*
  interface AssertedBlockScope : Node {
     FrozenArray<IdentifierName> lexicallyDeclaredNames;
     FrozenArray<IdentifierName> capturedNames;
     bool hasDirectEval;
  }
 */
-JS::Result<Ok>
-BinASTParser::parseAssertedBlockScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssertedBlockScope(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<Ok>
-BinASTParser::parseInterfaceAssertedBlockScope(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval }));
     MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let));
     MOZ_TRY(parseAndUpdateCapturedNames());
 
 
 
-    MOZ_TRY_DECL(hasDirectEval, readBool());
+    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;
+    auto result = Ok();
+    return result;
 }
 
 
 /*
  interface AssertedParameterScope : Node {
     FrozenArray<IdentifierName> parameterNames;
     FrozenArray<IdentifierName> capturedNames;
     bool hasDirectEval;
  }
 */
-JS::Result<Ok>
-BinASTParser::parseAssertedParameterScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssertedParameterScope(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<Ok>
-BinASTParser::parseInterfaceAssertedParameterScope(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::ParameterNames, BinField::CapturedNames, BinField::HasDirectEval }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::ParameterNames, BinField::CapturedNames, BinField::HasDirectEval }));
     MOZ_TRY(parseAndUpdateScopeNames(parseContext_->functionScope(), DeclarationKind:: PositionalFormalParameter));
     MOZ_TRY(parseAndUpdateCapturedNames());
 
 
 
-    MOZ_TRY_DECL(hasDirectEval, readBool());
+    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;
+    auto result = Ok();
+    return result;
 }
 
 
 /*
  interface AssertedVarScope : Node {
     FrozenArray<IdentifierName> lexicallyDeclaredNames;
     FrozenArray<IdentifierName> varDeclaredNames;
     FrozenArray<IdentifierName> capturedNames;
     bool hasDirectEval;
  }
 */
-JS::Result<Ok>
-BinASTParser::parseAssertedVarScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssertedVarScope(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<Ok>
-BinASTParser::parseInterfaceAssertedVarScope(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::VarDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::LexicallyDeclaredNames, BinField::VarDeclaredNames, BinField::CapturedNames, BinField::HasDirectEval }));
     MOZ_TRY(parseAndUpdateScopeNames(*parseContext_->innermostScope(), DeclarationKind::Let));
     MOZ_TRY(parseAndUpdateScopeNames(parseContext_->varScope(), DeclarationKind::Var));
     MOZ_TRY(parseAndUpdateCapturedNames());
 
 
 
-    MOZ_TRY_DECL(hasDirectEval, readBool());
+    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;
+    auto result = Ok();
+    return result;
 }
 
 
 /*
  interface AssignmentExpression : Node {
     AssignmentTarget binding;
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssignmentExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::AssignmentExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Binding, BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Binding, BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(binding, parseAssignmentTarget());
 
 
 
 
     MOZ_TRY_DECL(expression, parseExpression());
 
 
-    TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression));return result;
+    TRY_DECL(result, factory_.newAssignment(ParseNodeKind::Assign, binding, expression));
+    return result;
 }
 
 
 /*
  interface AssignmentTargetIdentifier : Node {
     Identifier name;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetIdentifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetIdentifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAssignmentTargetIdentifier(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Name }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name }));
 
 
     RootedAtom name(cx_);
-    MOZ_TRY(readString(&name));
+    MOZ_TRY_VAR(name, tokenizer_->readAtom());
 
 
     if (!IsIdentifier(name))
         return raiseError("Invalid identifier");
-    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));return result;
+    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
+    return result;
 }
 
 
 /*
  interface AssignmentTargetPropertyIdentifier : Node {
     AssignmentTargetIdentifier binding;
     Expression? init;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetPropertyIdentifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyIdentifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAssignmentTargetPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (AssignmentTargetPropertyIdentifier)");
 }
 
 
 /*
  interface AssignmentTargetPropertyProperty : Node {
     PropertyName name;
     (AssignmentTarget or AssignmentTargetWithInitializer) binding;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetPropertyProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetPropertyProperty(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAssignmentTargetPropertyProperty(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (AssignmentTargetPropertyProperty)");
 }
 
 
 /*
  interface AssignmentTargetWithInitializer : Node {
     AssignmentTarget binding;
     Expression init;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAssignmentTargetWithInitializer()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAssignmentTargetWithInitializer(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAssignmentTargetWithInitializer(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (AssignmentTargetWithInitializer)");
 }
 
 
 /*
  interface AwaitExpression : Node {
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseAwaitExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceAwaitExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceAwaitExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (AwaitExpression)");
 }
 
 
 /*
  interface BinaryExpression : Node {
     BinaryOperator operator;
     Expression left;
     Expression right;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBinaryExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBinaryExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBinaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceBinaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::BinaryExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Operator, BinField::Left, BinField::Right }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Left, BinField::Right }));
 
 
 
     MOZ_TRY_DECL(operator_, parseBinaryOperator());
 
 
 
 
@@ -2900,171 +3126,173 @@ BinASTParser::parseInterfaceBinaryExpres
         left->appendWithoutOrderAssumption(right);
         result = left;
     } else {
         TRY_DECL(list, factory_.newList(pnk, tokenizer_->pos(start)));
 
         list->appendWithoutOrderAssumption(left);
         list->appendWithoutOrderAssumption(right);
         result = list;
-    }return result;
+    }
+    return result;
 }
 
 
 /*
  interface BindingIdentifier : Node {
     Identifier name;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingIdentifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBindingIdentifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBindingIdentifier(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Name }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name }));
 
 
     RootedAtom name(cx_);
-    MOZ_TRY(readString(&name));
+    MOZ_TRY_VAR(name, tokenizer_->readAtom());
 
 
     if (!IsIdentifier(name))
         return raiseError("Invalid identifier");
-    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));return result;
+    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
+    return result;
 }
 
 
 /*
  interface BindingPropertyIdentifier : Node {
     BindingIdentifier binding;
     Expression? init;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingPropertyIdentifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBindingPropertyIdentifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBindingPropertyIdentifier(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (BindingPropertyIdentifier)");
 }
 
 
 /*
  interface BindingPropertyProperty : Node {
     PropertyName name;
     (Binding or BindingWithInitializer) binding;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingPropertyProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBindingPropertyProperty(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBindingPropertyProperty(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (BindingPropertyProperty)");
 }
 
 
 /*
  interface BindingWithInitializer : Node {
     Binding binding;
     Expression init;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBindingWithInitializer()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBindingWithInitializer(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBindingWithInitializer(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (BindingWithInitializer)");
 }
 
 
 /*
  interface Block : Node {
     AssertedBlockScope? scope;
     FrozenArray<Statement> statements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBlock()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBlock(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBlock(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceBlock(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::Block);
     CheckRecursionLimit(cx_);
 
     MOZ_TRY(checkFields(kind, fields, { BinField::Scope, BinField::Statements }));
     ParseContext::Statement stmt(parseContext_, StatementKind::Block);
     ParseContext::Scope currentScope(cx_, parseContext_, usedNames_);
     TRY(currentScope.init(parseContext_));
@@ -3084,90 +3312,91 @@ BinASTParser::parseInterfaceBlock(const 
 }
 
 
 /*
  interface BreakStatement : Node {
     Label? label;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseBreakStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceBreakStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceBreakStatement(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Label }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Label }));
     RootedAtom label(cx_);
-    MOZ_TRY(readMaybeString(&label));
-
-    if (label && !IsIdentifier(label))
-        return raiseError("Invalid identifier");
+    MOZ_TRY_VAR(label, tokenizer_->readMaybeAtom());
 
     if (label) {
+        if (!IsIdentifier(label))
+            return raiseError("Invalid identifier");
+
         auto validity = parseContext_->checkBreakStatement(label->asPropertyName());
 
         if (validity.isErr()) {
             switch (validity.unwrapErr()) {
             case ParseContext::BreakStatementError::ToughBreak:
                 return raiseError(kind, "Not in a loop");
             case ParseContext::BreakStatementError::LabelNotFound:
                 return raiseError(kind, "Label not found");
             }
         }
     }
-    TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start)));return result;
+    TRY_DECL(result, factory_.newBreakStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start)));
+    return result;
 }
 
 
 /*
  interface CallExpression : Node {
     (Expression or Super) callee;
     Arguments arguments;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseCallExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceCallExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceCallExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceCallExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::CallExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Callee, BinField::Arguments }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Callee, BinField::Arguments }));
 
 
 
     MOZ_TRY_DECL(callee, parseExpressionOrSuper());
 
 
 
 
@@ -3184,193 +3413,201 @@ BinASTParser::parseInterfaceCallExpressi
                 return raiseMissingDirectEvalInAssertedScope();
 
             op = parseContext_->sc()->strict() ? JSOP_STRICTEVAL : JSOP_EVAL;
         }
     }
     auto result = arguments;
     result->setKind(ParseNodeKind::Call);
     result->prepend(callee);
-    result->setOp(op);return result;
+    result->setOp(op);
+    return result;
 }
 
 
 /*
  interface CatchClause : Node {
+    AssertedParameterScope? bindingScope;
     Binding binding;
     Block body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseCatchClause()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseCatchClause()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     const auto start = tokenizer_->offset();
 
     MOZ_TRY_DECL(result, parseInterfaceCatchClause(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceCatchClause(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceCatchClause(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::CatchClause);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Binding, BinField::Body }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::BindingScope, BinField::Binding, BinField::Body }));
     ParseContext::Statement stmt(parseContext_, StatementKind::Catch);
     ParseContext::Scope currentScope(cx_, parseContext_, usedNames_);
     TRY(currentScope.init(parseContext_));
 
 
+    MOZ_TRY(parseOptionalAssertedParameterScope());
+
+
+
+
     MOZ_TRY_DECL(binding, parseBinding());
 
 
 
 
     MOZ_TRY_DECL(body, parseBlock());
 
 
     // Export implicit variables to the scope.
     // FIXME: Handle cases other than Name.
     MOZ_ASSERT(binding->isKind(ParseNodeKind::Name));
     auto ptr = currentScope.lookupDeclaredNameForAdd(binding->name());
     TRY(currentScope.addDeclaredName(parseContext_, ptr, binding->name(), DeclarationKind::Let, start));
 
     TRY_DECL(bindings, NewLexicalScopeData(cx_, currentScope, alloc_, parseContext_));
     TRY_DECL(result, factory_.newLexicalScope(*bindings, body));
-    TRY(factory_.setupCatchScope(result, binding, body));return result;
+    TRY(factory_.setupCatchScope(result, binding, body));
+    return result;
 }
 
 
 /*
  interface ClassDeclaration : Node {
     BindingIdentifier name;
     Expression? super;
     FrozenArray<ClassElement> elements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseClassDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceClassDeclaration(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceClassDeclaration(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ClassDeclaration)");
 }
 
 
 /*
  interface ClassElement : Node {
     bool isStatic;
     MethodDefinition method;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseClassElement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceClassElement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceClassElement(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ClassElement)");
 }
 
 
 /*
  interface ClassExpression : Node {
     BindingIdentifier? name;
     Expression? super;
     FrozenArray<ClassElement> elements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseClassExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceClassExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceClassExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ClassExpression)");
 }
 
 
 /*
  interface CompoundAssignmentExpression : Node {
     CompoundAssignmentOperator operator;
     SimpleAssignmentTarget binding;
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseCompoundAssignmentExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceCompoundAssignmentExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceCompoundAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceCompoundAssignmentExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::CompoundAssignmentExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Operator, BinField::Binding, BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Binding, BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(operator_, parseCompoundAssignmentOperator());
 
 
 
 
@@ -3416,1098 +3653,510 @@ BinASTParser::parseInterfaceCompoundAssi
         break;
       case CompoundAssignmentOperator::BitXorAssign:
         pnk = ParseNodeKind::BitXorAssign;
         break;
       case CompoundAssignmentOperator::BitAndAssign:
         pnk = ParseNodeKind::BitAndAssign;
         break;
     }
-    TRY_DECL(result, factory_.newAssignment(pnk, binding, expression));return result;
+    TRY_DECL(result, factory_.newAssignment(pnk, binding, expression));
+    return result;
 }
 
 
 /*
  interface ComputedMemberAssignmentTarget : Node {
     (Expression or Super) object;
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseComputedMemberAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceComputedMemberAssignmentTarget(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceComputedMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceComputedMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ComputedMemberAssignmentTarget);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Object, BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(object, parseExpressionOrSuper());
 
 
 
 
     MOZ_TRY_DECL(expression, parseExpression());
 
 
-    TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));return result;
+    TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));
+    return result;
 }
 
 
 /*
  interface ComputedMemberExpression : Node {
     (Expression or Super) object;
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseComputedMemberExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceComputedMemberExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceComputedMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceComputedMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ComputedMemberExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Object, BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(object, parseExpressionOrSuper());
 
 
 
 
     MOZ_TRY_DECL(expression, parseExpression());
 
 
-    TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));return result;
+    TRY_DECL(result, factory_.newPropertyByValue(object, expression, start));
+    return result;
 }
 
 
 /*
  interface ComputedPropertyName : Node {
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseComputedPropertyName()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceComputedPropertyName(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceComputedPropertyName(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ComputedPropertyName)");
 }
 
 
 /*
  interface ConditionalExpression : Node {
     Expression test;
     Expression consequent;
     Expression alternate;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseConditionalExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceConditionalExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceConditionalExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ConditionalExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate }));
 
 
 
     MOZ_TRY_DECL(test, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(consequent, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(alternate, parseExpression());
 
 
-    TRY_DECL(result, factory_.newConditional(test, consequent, alternate));return result;
+    TRY_DECL(result, factory_.newConditional(test, consequent, alternate));
+    return result;
 }
 
 
 /*
  interface ContinueStatement : Node {
     Label? label;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseContinueStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceContinueStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceContinueStatement(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Label }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Label }));
     RootedAtom label(cx_);
-    MOZ_TRY(readMaybeString(&label));
-
-    if (label && !IsIdentifier(label))
-        return raiseError("ContinueStatement - Label MUST be an identifier");
+    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);
         if (validity.isErr()) {
             switch (validity.unwrapErr()) {
               case ParseContext::ContinueStatementError::NotInALoop:
                 return raiseError(kind, "Not in a loop");
               case ParseContext::ContinueStatementError::LabelNotFound:
                 return raiseError(kind, "Label not found");
             }
         }
     }
 
-    TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start)));return result;
+    TRY_DECL(result, factory_.newContinueStatement(label ? label->asPropertyName() : nullptr, tokenizer_->pos(start)));
+    return result;
 }
 
 
 /*
  interface DataProperty : Node {
     PropertyName name;
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseDataProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceDataProperty(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceDataProperty(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceDataProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::DataProperty);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Name, BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name, BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(name, parsePropertyName());
 
 
 
 
     MOZ_TRY_DECL(expression, parseExpression());
 
 
     if (!factory_.isUsableAsObjectPropertyName(name))
         return raiseError("DataProperty key kind");
 
-    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None));return result;
+    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, expression, AccessorType::None));
+    return result;
 }
 
 
 /*
  interface DebuggerStatement : Node {
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseDebuggerStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceDebuggerStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceDebuggerStatement(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (DebuggerStatement)");
 }
 
 
 /*
  interface Directive : Node {
     string rawValue;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseDirective()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceDirective(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceDirective(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::RawValue }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::RawValue }));
 
 
     RootedAtom rawValue(cx_);
-    MOZ_TRY(readString(&rawValue));
+    MOZ_TRY_VAR(rawValue, tokenizer_->readAtom());
 
 
     TokenPos pos = tokenizer_->pos(start);
-    TRY_DECL(result, factory_.newStringLiteral(rawValue, pos));return result;
+    TRY_DECL(result, factory_.newStringLiteral(rawValue, pos));
+    return result;
 }
 
 
 /*
  interface DoWhileStatement : Node {
     Expression test;
     Statement body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseDoWhileStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceDoWhileStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceDoWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceDoWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::DoWhileStatement);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Test, BinField::Body }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Body }));
     ParseContext::Statement stmt(parseContext_, StatementKind::DoLoop);
 
 
     MOZ_TRY_DECL(test, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(body, parseStatement());
 
 
-    TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface EmptyStatement : Node {
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseEmptyStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceEmptyStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceEmptyStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::EmptyStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields0(kind, fields));
-
-    TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface Export : Node {
-    (FunctionDeclaration or ClassDeclaration or VariableDeclaration) declaration;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExport()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExport(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExport(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (Export)");
-}
-
-
-/*
- interface ExportAllFrom : Node {
-    string moduleSpecifier;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportAllFrom()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportAllFrom(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportAllFrom(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportAllFrom)");
-}
-
-
-/*
- interface ExportDefault : Node {
-    (FunctionDeclaration or ClassDeclaration or Expression) body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportDefault()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportDefault(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportDefault(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportDefault)");
-}
-
-
-/*
- interface ExportFrom : Node {
-    FrozenArray<ExportFromSpecifier> namedExports;
-    string moduleSpecifier;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportFrom()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportFrom(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportFrom(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportFrom)");
-}
-
-
-/*
- interface ExportFromSpecifier : Node {
-    IdentifierName name;
-    IdentifierName? exportedName;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportFromSpecifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportFromSpecifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportFromSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportFromSpecifier)");
-}
-
-
-/*
- interface ExportLocalSpecifier : Node {
-    IdentifierExpression name;
-    IdentifierName? exportedName;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportLocalSpecifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportLocalSpecifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportLocalSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportLocalSpecifier)");
-}
-
-
-/*
- interface ExportLocals : Node {
-    FrozenArray<ExportLocalSpecifier> namedExports;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExportLocals()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExportLocals(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExportLocals(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ExportLocals)");
-}
-
-
-/*
- interface ExpressionStatement : Node {
-    Expression expression;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseExpressionStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceExpressionStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::ExpressionStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Expression }));
-
-
-
-    MOZ_TRY_DECL(expression, parseExpression());
-
-
-    TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset()));return result;
-}
-
-
-/*
- interface ForInOfBinding : Node {
-    VariableDeclarationKind kind;
-    Binding binding;
+    TRY_DECL(result, factory_.newDoWhileStatement(body, test, tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface EagerArrowExpression : Node {
+    bool isAsync;
+    AssertedParameterScope? parameterScope;
+    AssertedVarScope? bodyScope;
+    FormalParameters params;
+    (FunctionBody or Expression) body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseForInOfBinding()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceForInOfBinding(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceForInOfBinding(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::ForInOfBinding);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Kind, BinField::Binding }));
-    AutoVariableDeclarationKind kindGuard(this);
-
-
-    MOZ_TRY_DECL(kind_, parseVariableDeclarationKind());
-
-
-
-
-    MOZ_TRY_DECL(binding, parseBinding());
-
-
-    // Restored by `kindGuard`.
-    variableDeclarationKind_ = kind_;
-    MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName()));
-    auto pnk =
-        kind_ == VariableDeclarationKind::Let
-            ? ParseNodeKind::Let
-            : ParseNodeKind::Var;
-    TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start)));
-    factory_.addList(result, binding);return result;
-}
-
-
-/*
- interface ForInStatement : Node {
-    (ForInOfBinding or AssignmentTarget) left;
-    Expression right;
-    Statement body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseForInStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceForInStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceForInStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::ForInStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Left, BinField::Right, BinField::Body }));
-    ParseContext::Statement stmt(parseContext_, StatementKind::ForInLoop);
-
-    // Implicit scope around the `for`, used to store `for (let x in  ...)`
-    // or `for (const x in ...)`-style declarations. Detail on the
-    // declaration is stored as part of `scope`.
-    ParseContext::Scope scope(cx_, parseContext_, usedNames_);
-    TRY(scope.init(parseContext_));
-
-
-    MOZ_TRY_DECL(left, parseForInOfBindingOrAssignmentTarget());
-
-
-
-
-    MOZ_TRY_DECL(right, parseExpression());
-
-
-
-
-    MOZ_TRY_DECL(body, parseStatement());
-
-
-    TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start)));
-    TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0));
-
-    if (!scope.isEmpty()) {
-        TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
-        TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
-    }return result;
-}
-
-
-/*
- interface ForOfStatement : Node {
-    (ForInOfBinding or AssignmentTarget) left;
-    Expression right;
-    Statement body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseForOfStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceForOfStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceForOfStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ForOfStatement)");
-}
-
-
-/*
- interface ForStatement : Node {
-    (VariableDeclaration or Expression)? init;
-    Expression? test;
-    Expression? update;
-    Statement body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseForStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceForStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceForStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::ForStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Init, BinField::Test, BinField::Update, BinField::Body }));
-    ParseContext::Statement stmt(parseContext_, StatementKind::ForLoop);
-
-    // Implicit scope around the `for`, used to store `for (let x; ...; ...)`
-    // or `for (const x; ...; ...)`-style declarations. Detail on the
-    // declaration is stored as part of `BINJS_Scope`.
-    ParseContext::Scope scope(cx_, parseContext_, usedNames_);
-    TRY(scope.init(parseContext_));
-
-
-    MOZ_TRY_DECL(init, parseOptionalVariableDeclarationOrExpression());
-
-
-
-
-    MOZ_TRY_DECL(test, parseOptionalExpression());
-
-
-
-
-    MOZ_TRY_DECL(update, parseOptionalExpression());
-
-
-
-
-    MOZ_TRY_DECL(body, parseStatement());
-
-
-    TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start)));
-    TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0));
-
-    if (!scope.isEmpty()) {
-        TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
-        TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
-    }return result;
-}
-
-
-/*
- interface FormalParameters : Node {
-    FrozenArray<Parameter> items;
-    Binding? rest;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseFormalParameters()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceFormalParameters(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceFormalParameters(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::FormalParameters);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Items, BinField::Rest }));
-
-
-
-    MOZ_TRY_DECL(items, parseListOfParameter());
-
-
-
-
-    MOZ_TRY_DECL(rest, parseOptionalBinding());
-
-
-    auto result = items;
-    if (rest) {
-        TRY_DECL(spread, factory_.newSpread(start, rest));
-        factory_.addList(result, spread);
-    }return result;
-}
-
-
-/*
- interface FunctionBody : Node {
-    FrozenArray<Directive> directives;
-    FrozenArray<Statement> statements;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionBody()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceFunctionBody(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::FunctionBody);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Directives, BinField::Statements }));
-
-
-
-    MOZ_TRY_DECL(directives, parseListOfDirective());
-
-
-
-
-    MOZ_TRY_DECL(statements, parseListOfStatement());
-
-
-    MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));return result;
-}
-
-
-/*
- interface FunctionDeclaration : Node {
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (EagerArrowExpression)");
+}
+
+
+/*
+ interface EagerFunctionDeclaration : Node {
     bool isAsync;
     bool isGenerator;
     AssertedParameterScope? parameterScope;
     AssertedVarScope? bodyScope;
     BindingIdentifier name;
     FormalParameters params;
     FunctionBody body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceFunctionDeclaration(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::FunctionDeclaration);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body }));
-
-
-
-    MOZ_TRY_DECL(isAsync, readBool());
-
-
-
-
-    MOZ_TRY_DECL(isGenerator, readBool());
-
-
-    MOZ_TRY_DECL(funbox, buildFunctionBox(
-        isGenerator ? GeneratorKind::Generator
-                    : GeneratorKind::NotGenerator,
-        isAsync ? FunctionAsyncKind::AsyncFunction
-                : FunctionAsyncKind::SyncFunction));
-
-    // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
-    BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
-    TRY(funpc.init());
-    parseContext_->functionScope().useAsVarScope(parseContext_);
-    MOZ_ASSERT(parseContext_->isFunctionBox());
-
-    ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
-    TRY(lexicalScope.init(parseContext_));
-
-    MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
-
-    MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
-
-    MOZ_TRY_DECL(name, parseBindingIdentifier());
-
-
-
-
-    MOZ_TRY_DECL(params, parseFormalParameters());
-
-
-
-
-    MOZ_TRY_DECL(body, parseFunctionBody());
-
-
-    TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_));
-    TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body));
-    MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox));return result;
-}
-
-
-/*
- interface FunctionExpression : Node {
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEagerFunctionDeclaration(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEagerFunctionDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    return raiseError("FIXME: Not implemented yet (EagerFunctionDeclaration)");
+}
+
+
+/*
+ interface EagerFunctionExpression : Node {
     bool isAsync;
     bool isGenerator;
     AssertedParameterScope? parameterScope;
     AssertedVarScope? bodyScope;
     BindingIdentifier? name;
     FormalParameters params;
     FunctionBody body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseFunctionExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceFunctionExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::FunctionExpression);
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEagerFunctionExpression(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEagerFunctionExpression(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::EagerFunctionExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body }));
-
-
-
-    MOZ_TRY_DECL(isAsync, readBool());
-
-
-
-
-    MOZ_TRY_DECL(isGenerator, readBool());
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body }));
+
+
+
+    MOZ_TRY_DECL(isAsync, tokenizer_->readBool());
+
+
+
+
+    MOZ_TRY_DECL(isGenerator, tokenizer_->readBool());
 
 
     MOZ_TRY_DECL(funbox, buildFunctionBox(
         isGenerator ? GeneratorKind::Generator
                     : GeneratorKind::NotGenerator,
         isAsync ? FunctionAsyncKind::AsyncFunction
                 : FunctionAsyncKind::SyncFunction));
 
@@ -4540,598 +4189,94 @@ BinASTParser::parseInterfaceFunctionExpr
 
 
 
     MOZ_TRY_DECL(body, parseFunctionBody());
 
 
     TRY_DECL(lexicalScopeData, NewLexicalScopeData(cx_, lexicalScope, alloc_, parseContext_));
     TRY_VAR(body, factory_.newLexicalScope(*lexicalScopeData, body));
-    MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox));return result;
-}
-
-
-/*
- interface Getter : Node {
+    MOZ_TRY_DECL(result, buildFunction(start, kind, name, params, body, funbox));
+    return result;
+}
+
+
+/*
+ interface EagerGetter : Node {
     AssertedVarScope? bodyScope;
     PropertyName name;
     FunctionBody body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseGetter()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceGetter(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceGetter(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (Getter)");
-}
-
-
-/*
- interface IdentifierExpression : Node {
-    Identifier name;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseIdentifierExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceIdentifierExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceIdentifierExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::IdentifierExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Name }));
-
-
-    RootedAtom name(cx_);
-    MOZ_TRY(readString(&name));
-
-
-    if (!IsIdentifier(name))
-        return raiseError("Invalid identifier");
-    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));return result;
-}
-
-
-/*
- interface IfStatement : Node {
-    Expression test;
-    Statement consequent;
-    Statement? alternate;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseIfStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceIfStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceIfStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::IfStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate }));
-
-
-
-    MOZ_TRY_DECL(test, parseExpression());
-
-
-
-
-    MOZ_TRY_DECL(consequent, parseStatement());
-
-
-
-
-    MOZ_TRY_DECL(alternate, parseOptionalStatement());
-
-
-    TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate));return result;
-}
-
-
-/*
- interface Import : Node {
-    string moduleSpecifier;
-    BindingIdentifier? defaultBinding;
-    FrozenArray<ImportSpecifier> namedImports;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseImport()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceImport(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceImport(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (Import)");
-}
-
-
-/*
- interface ImportNamespace : Node {
-    string moduleSpecifier;
-    BindingIdentifier? defaultBinding;
-    BindingIdentifier namespaceBinding;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseImportNamespace()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceImportNamespace(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceImportNamespace(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ImportNamespace)");
-}
-
-
-/*
- interface ImportSpecifier : Node {
-    IdentifierName? name;
-    BindingIdentifier binding;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseImportSpecifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceImportSpecifier(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceImportSpecifier(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (ImportSpecifier)");
-}
-
-
-/*
- interface LabelledStatement : Node {
-    Label label;
-    Statement body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLabelledStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLabelledStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLabelledStatement(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LabelledStatement);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Label, BinField::Body }));
-
-
-    RootedAtom label(cx_);
-    MOZ_TRY(readString(&label));
-    if (!IsIdentifier(label))
-        return raiseError("Invalid identifier");
-    ParseContext::LabelStatement stmt(parseContext_, label);
-
-
-
-    MOZ_TRY_DECL(body, parseStatement());
-
-
-    TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start));return result;
-}
-
-
-/*
- interface LiteralBooleanExpression : Node {
-    bool value;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralBooleanExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Value }));
-
-
-
-    MOZ_TRY_DECL(value, readBool());
-
-
-    TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface LiteralInfinityExpression : Node {
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralInfinityExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralInfinityExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralInfinityExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (LiteralInfinityExpression)");
-}
-
-
-/*
- interface LiteralNullExpression : Node {
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralNullExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralNullExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralNullExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields0(kind, fields));
-
-    TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface LiteralNumericExpression : Node {
-    number value;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralNumericExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralNumericExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralNumericExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Value }));
-
-
-
-    MOZ_TRY_DECL(value, readNumber());
-
-
-    TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface LiteralPropertyName : Node {
-    string value;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralPropertyName()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralPropertyName(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralPropertyName(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralPropertyName);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Value }));
-
-
-    RootedAtom value(cx_);
-    MOZ_TRY(readString(&value));
-
-
-    ParseNode* result;
-    uint32_t index;
-    if (value->isIndex(&index))
-        TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset())));
-    else
-        TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface LiteralRegExpExpression : Node {
-    string pattern;
-    string flags;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralRegExpExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralRegExpExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralRegExpExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralRegExpExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Pattern, BinField::Flags }));
-
-
-    RootedAtom pattern(cx_);
-    MOZ_TRY(readString(&pattern));
-
-    Chars flags(cx_); MOZ_TRY(readString(flags));
-
-    RegExpFlag reflags = NoFlags;
-    for (auto c : flags) {
-        if (c == 'g' && !(reflags & GlobalFlag))
-            reflags = RegExpFlag(reflags | GlobalFlag);
-        else if (c == 'i' && !(reflags & IgnoreCaseFlag))
-            reflags = RegExpFlag(reflags | IgnoreCaseFlag);
-        else if (c == 'm' && !(reflags & MultilineFlag))
-            reflags = RegExpFlag(reflags | MultilineFlag);
-        else if (c == 'y' && !(reflags & StickyFlag))
-            reflags = RegExpFlag(reflags | StickyFlag);
-        else if (c == 'u' && !(reflags & UnicodeFlag))
-            reflags = RegExpFlag(reflags | UnicodeFlag);
-        else
-            return raiseInvalidEnum("RegExpLiteral", flags);
-    }
-
-
-    Rooted<RegExpObject*> reobj(cx_);
-    TRY_VAR(reobj, RegExpObject::create(cx_,
-        pattern,
-        reflags,
-        alloc_,
-        TenuredObject));
-
-    TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this));return result;
-}
-
-
-/*
- interface LiteralStringExpression : Node {
-    string value;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseLiteralStringExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceLiteralStringExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceLiteralStringExpression(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::LiteralStringExpression);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::Value }));
-
-
-    RootedAtom value(cx_);
-    MOZ_TRY(readString(&value));
-
-
-    TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start)));return result;
-}
-
-
-/*
- interface Method : Node {
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEagerGetter(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEagerGetter(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    return raiseError("FIXME: Not implemented yet (EagerGetter)");
+}
+
+
+/*
+ interface EagerMethod : Node {
     bool isAsync;
     bool isGenerator;
     AssertedParameterScope? parameterScope;
     AssertedVarScope? bodyScope;
     PropertyName name;
     FormalParameters params;
     FunctionBody body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseMethod()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceMethod(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceMethod(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::Method);
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEagerMethod(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEagerMethod(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::EagerMethod);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body }));
-
-
-
-    MOZ_TRY_DECL(isAsync, readBool());
-
-
-
-
-    MOZ_TRY_DECL(isGenerator, readBool());
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsAsync, BinField::IsGenerator, BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Params, BinField::Body }));
+
+
+
+    MOZ_TRY_DECL(isAsync, tokenizer_->readBool());
+
+
+
+
+    MOZ_TRY_DECL(isGenerator, tokenizer_->readBool());
 
 
     MOZ_TRY_DECL(funbox, buildFunctionBox(
         isGenerator ? GeneratorKind::Generator
                     : GeneratorKind::NotGenerator,
         isAsync ? FunctionAsyncKind::AsyncFunction
                 : FunctionAsyncKind::SyncFunction));
 
@@ -5163,730 +4308,1958 @@ BinASTParser::parseInterfaceMethod(const
 
 
 
 
     MOZ_TRY_DECL(body, parseFunctionBody());
 
 
     MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox));
-    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None));return result;
+    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::None));
+    return result;
+}
+
+
+/*
+ interface EagerSetter : Node {
+    AssertedParameterScope? parameterScope;
+    AssertedVarScope? bodyScope;
+    PropertyName name;
+    Parameter param;
+    FunctionBody body;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEagerSetter(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEagerSetter(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    return raiseError("FIXME: Not implemented yet (EagerSetter)");
+}
+
+
+/*
+ interface EmptyStatement : Node {
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceEmptyStatement(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceEmptyStatement(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::EmptyStatement);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields0(kind, fields));
+
+    TRY_DECL(result, factory_.newEmptyStatement(tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface Export : Node {
+    (FunctionDeclaration or ClassDeclaration or VariableDeclaration) declaration;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (Export)");
+}
+
+
+/*
+ interface ExportAllFrom : Node {
+    string moduleSpecifier;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportAllFrom)");
+}
+
+
+/*
+ interface ExportDefault : Node {
+    (FunctionDeclaration or ClassDeclaration or Expression) body;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportDefault)");
+}
+
+
+/*
+ interface ExportFrom : Node {
+    FrozenArray<ExportFromSpecifier> namedExports;
+    string moduleSpecifier;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportFrom)");
+}
+
+
+/*
+ interface ExportFromSpecifier : Node {
+    IdentifierName name;
+    IdentifierName? exportedName;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportFromSpecifier)");
+}
+
+
+/*
+ interface ExportLocalSpecifier : Node {
+    IdentifierExpression name;
+    IdentifierName? exportedName;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportLocalSpecifier)");
+}
+
+
+/*
+ interface ExportLocals : Node {
+    FrozenArray<ExportLocalSpecifier> namedExports;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ExportLocals)");
+}
+
+
+/*
+ interface ExpressionStatement : Node {
+    Expression expression;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceExpressionStatement(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceExpressionStatement(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::ExpressionStatement);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Expression }));
+
+
+
+    MOZ_TRY_DECL(expression, parseExpression());
+
+
+    TRY_DECL(result, factory_.newExprStatement(expression, tokenizer_->offset()));
+    return result;
+}
+
+
+/*
+ interface ForInOfBinding : Node {
+    VariableDeclarationKind kind;
+    Binding binding;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceForInOfBinding(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceForInOfBinding(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::ForInOfBinding);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Kind, BinField::Binding }));
+    AutoVariableDeclarationKind kindGuard(this);
+
+
+    MOZ_TRY_DECL(kind_, parseVariableDeclarationKind());
+
+
+
+
+    MOZ_TRY_DECL(binding, parseBinding());
+
+
+    // Restored by `kindGuard`.
+    variableDeclarationKind_ = kind_;
+    MOZ_TRY(checkBinding(binding->pn_atom->asPropertyName()));
+    auto pnk =
+        kind_ == VariableDeclarationKind::Let
+            ? ParseNodeKind::Let
+            : ParseNodeKind::Var;
+    TRY_DECL(result, factory_.newDeclarationList(pnk, tokenizer_->pos(start)));
+    factory_.addList(result, binding);
+    return result;
+}
+
+
+/*
+ interface ForInStatement : Node {
+    (ForInOfBinding or AssignmentTarget) left;
+    Expression right;
+    Statement body;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Left, BinField::Right, BinField::Body }));
+    ParseContext::Statement stmt(parseContext_, StatementKind::ForInLoop);
+
+    // Implicit scope around the `for`, used to store `for (let x in  ...)`
+    // or `for (const x in ...)`-style declarations. Detail on the
+    // declaration is stored as part of `scope`.
+    ParseContext::Scope scope(cx_, parseContext_, usedNames_);
+    TRY(scope.init(parseContext_));
+
+
+    MOZ_TRY_DECL(left, parseForInOfBindingOrAssignmentTarget());
+
+
+
+
+    MOZ_TRY_DECL(right, parseExpression());
+
+
+
+
+    MOZ_TRY_DECL(body, parseStatement());
+
+
+    TRY_DECL(forHead, factory_.newForInOrOfHead(ParseNodeKind::ForIn, left, right, tokenizer_->pos(start)));
+    TRY_DECL(result, factory_.newForStatement(start, forHead, body, /*flags*/ 0));
+
+    if (!scope.isEmpty()) {
+        TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
+        TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
+    }
+    return result;
+}
+
+
+/*
+ interface ForOfStatement : Node {
+    (ForInOfBinding or AssignmentTarget) left;
+    Expression right;
+    Statement body;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ForOfStatement)");
+}
+
+
+/*
+ interface ForStatement : Node {
+    (VariableDeclaration or Expression)? init;
+    Expression? test;
+    Expression? update;
+    Statement body;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Init, BinField::Test, BinField::Update, BinField::Body }));
+    ParseContext::Statement stmt(parseContext_, StatementKind::ForLoop);
+
+    // Implicit scope around the `for`, used to store `for (let x; ...; ...)`
+    // or `for (const x; ...; ...)`-style declarations. Detail on the
+    // declaration is stored as part of `BINJS_Scope`.
+    ParseContext::Scope scope(cx_, parseContext_, usedNames_);
+    TRY(scope.init(parseContext_));
+
+
+    MOZ_TRY_DECL(init, parseOptionalVariableDeclarationOrExpression());
+
+
+
+
+    MOZ_TRY_DECL(test, parseOptionalExpression());
+
+
+
+
+    MOZ_TRY_DECL(update, parseOptionalExpression());
+
+
+
+
+    MOZ_TRY_DECL(body, parseStatement());
+
+
+    TRY_DECL(forHead, factory_.newForHead(init, test, update, tokenizer_->pos(start)));
+    TRY_DECL(result, factory_.newForStatement(start, forHead, body, /* iflags = */ 0));
+
+    if (!scope.isEmpty()) {
+        TRY_DECL(bindings, NewLexicalScopeData(cx_, scope, alloc_, parseContext_));
+        TRY_VAR(result, factory_.newLexicalScope(*bindings, result));
+    }
+    return result;
+}
+
+
+/*
+ interface FormalParameters : Node {
+    FrozenArray<Parameter> items;
+    Binding? rest;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceFormalParameters(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceFormalParameters(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::FormalParameters);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Items, BinField::Rest }));
+
+
+
+    MOZ_TRY_DECL(items, parseListOfParameter());
+
+
+
+
+    MOZ_TRY_DECL(rest, parseOptionalBinding());
+
+
+    auto result = items;
+    if (rest) {
+        TRY_DECL(spread, factory_.newSpread(start, rest));
+        factory_.addList(result, spread);
+    }
+    return result;
+}
+
+
+/*
+ interface FunctionBody : Node {
+    FrozenArray<Directive> directives;
+    FrozenArray<Statement> statements;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceFunctionBody(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceFunctionBody(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::FunctionBody);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Directives, BinField::Statements }));
+
+
+
+    MOZ_TRY_DECL(directives, parseListOfDirective());
+
+
+
+
+    MOZ_TRY_DECL(statements, parseListOfStatement());
+
+
+    MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));
+    return result;
+}
+
+
+/*
+ interface IdentifierExpression : Node {
+    Identifier name;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name }));
+
+
+    RootedAtom name(cx_);
+    MOZ_TRY_VAR(name, tokenizer_->readAtom());
+
+
+    if (!IsIdentifier(name))
+        return raiseError("Invalid identifier");
+    TRY_DECL(result, factory_.newName(name->asPropertyName(), tokenizer_->pos(start), cx_));
+    return result;
+}
+
+
+/*
+ interface IfStatement : Node {
+    Expression test;
+    Statement consequent;
+    Statement? alternate;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceIfStatement(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceIfStatement(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::IfStatement);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent, BinField::Alternate }));
+
+
+
+    MOZ_TRY_DECL(test, parseExpression());
+
+
+
+
+    MOZ_TRY_DECL(consequent, parseStatement());
+
+
+
+
+    MOZ_TRY_DECL(alternate, parseOptionalStatement());
+
+
+    TRY_DECL(result, factory_.newIfStatement(start, test, consequent, alternate));
+    return result;
+}
+
+
+/*
+ interface Import : Node {
+    string moduleSpecifier;
+    BindingIdentifier? defaultBinding;
+    FrozenArray<ImportSpecifier> namedImports;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (Import)");
+}
+
+
+/*
+ interface ImportNamespace : Node {
+    string moduleSpecifier;
+    BindingIdentifier? defaultBinding;
+    BindingIdentifier namespaceBinding;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ImportNamespace)");
+}
+
+
+/*
+ interface ImportSpecifier : Node {
+    IdentifierName? name;
+    BindingIdentifier binding;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (ImportSpecifier)");
+}
+
+
+/*
+ interface LabelledStatement : Node {
+    Label label;
+    Statement body;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Label, BinField::Body }));
+
+
+    RootedAtom label(cx_);
+    MOZ_TRY_VAR(label, tokenizer_->readAtom());
+    if (!IsIdentifier(label))
+        return raiseError("Invalid identifier");
+    ParseContext::LabelStatement stmt(parseContext_, label);
+
+
+
+    MOZ_TRY_DECL(body, parseStatement());
+
+
+    TRY_DECL(result, factory_.newLabeledStatement(label->asPropertyName(), body, start));
+    return result;
+}
+
+
+/*
+ interface LiteralBooleanExpression : Node {
+    bool value;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceLiteralBooleanExpression(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceLiteralBooleanExpression(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::LiteralBooleanExpression);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value }));
+
+
+
+    MOZ_TRY_DECL(value, tokenizer_->readBool());
+
+
+    TRY_DECL(result, factory_.newBooleanLiteral(value, tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface LiteralInfinityExpression : Node {
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (LiteralInfinityExpression)");
+}
+
+
+/*
+ interface LiteralNullExpression : Node {
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceLiteralNullExpression(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceLiteralNullExpression(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::LiteralNullExpression);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields0(kind, fields));
+
+    TRY_DECL(result, factory_.newNullLiteral(tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface LiteralNumericExpression : Node {
+    number value;
+ }
+*/
+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();
+
+    MOZ_TRY_DECL(result, parseInterfaceLiteralNumericExpression(start, kind, fields));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceLiteralNumericExpression(const size_t start, const BinKind kind, const BinFields& fields)
+{
+    MOZ_ASSERT(kind == BinKind::LiteralNumericExpression);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value }));
+
+
+
+    MOZ_TRY_DECL(value, tokenizer_->readDouble());
+
+
+    TRY_DECL(result, factory_.newNumber(value, DecimalPoint::HasDecimal, tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface LiteralPropertyName : Node {
+    string value;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value }));
+
+
+    RootedAtom value(cx_);
+    MOZ_TRY_VAR(value, tokenizer_->readAtom());
+
+
+    ParseNode* result;
+    uint32_t index;
+    if (value->isIndex(&index))
+        TRY_VAR(result, factory_.newNumber(index, NoDecimal, TokenPos(start, tokenizer_->offset())));
+    else
+        TRY_VAR(result, factory_.newObjectLiteralPropertyName(value, tokenizer_->pos(start)));
+    return result;
+}
+
+
+/*
+ interface LiteralRegExpExpression : Node {
+    string pattern;
+    string flags;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Pattern, BinField::Flags }));
+
+
+    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))
+            reflags = RegExpFlag(reflags | IgnoreCaseFlag);
+        else if (c == 'm' && !(reflags & MultilineFlag))
+            reflags = RegExpFlag(reflags | MultilineFlag);
+        else if (c == 'y' && !(reflags & StickyFlag))
+            reflags = RegExpFlag(reflags | StickyFlag);
+        else if (c == 'u' && !(reflags & UnicodeFlag))
+            reflags = RegExpFlag(reflags | UnicodeFlag);
+        else
+            return raiseError("Invalid regexp flags");
+    }
+
+
+    Rooted<RegExpObject*> reobj(cx_);
+    TRY_VAR(reobj, RegExpObject::create(cx_,
+        pattern,
+        reflags,
+        alloc_,
+        TenuredObject));
+
+    TRY_DECL(result, factory_.newRegExp(reobj, tokenizer_->pos(start), *this));
+    return result;
+}
+
+
+/*
+ interface LiteralStringExpression : Node {
+    string value;
+ }
+*/
+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();
+
+    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);
+    CheckRecursionLimit(cx_);
+
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Value }));
+
+
+    RootedAtom value(cx_);
+    MOZ_TRY_VAR(value, tokenizer_->readAtom());
+
+
+    TRY_DECL(result, factory_.newStringLiteral(value, tokenizer_->pos(start)));
+    return result;
 }
 
 
 /*
  interface Module : Node {
     AssertedVarScope? scope;
     FrozenArray<Directive> directives;
     FrozenArray<(ImportDeclaration or ExportDeclaration or Statement)> items;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseModule()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceModule(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceModule(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (Module)");
 }
 
 
 /*
  interface NewExpression : Node {
     Expression callee;
     Arguments arguments;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseNewExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceNewExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceNewExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::NewExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Callee, BinField::Arguments }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Callee, BinField::Arguments }));
 
 
 
     MOZ_TRY_DECL(callee, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(arguments, parseArguments());
 
 
     auto result = arguments;
     result->setKind(ParseNodeKind::New);
-    result->prepend(callee);return result;
+    result->prepend(callee);
+    return result;
 }
 
 
 /*
  interface NewTargetExpression : Node {
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseNewTargetExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceNewTargetExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceNewTargetExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (NewTargetExpression)");
 }
 
 
 /*
  interface ObjectAssignmentTarget : Node {
     FrozenArray<AssignmentTargetProperty> properties;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseObjectAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceObjectAssignmentTarget(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceObjectAssignmentTarget(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ObjectAssignmentTarget)");
 }
 
 
 /*
  interface ObjectBinding : Node {
     FrozenArray<BindingProperty> properties;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseObjectBinding()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceObjectBinding(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceObjectBinding(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (ObjectBinding)");
 }
 
 
 /*
  interface ObjectExpression : Node {
     FrozenArray<ObjectProperty> properties;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseObjectExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceObjectExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceObjectExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ObjectExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Properties }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Properties }));
 
 
 
     MOZ_TRY_DECL(properties, parseListOfObjectProperty());
 
 
-    auto result = properties;return result;
+    auto result = properties;
+    return result;
 }
 
 
 /*
  interface ReturnStatement : Node {
     Expression? expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseReturnStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceReturnStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceReturnStatement(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Expression }));
     if (!parseContext_->isFunctionBox()) {
         // Return statements are permitted only inside functions.
         return raiseInvalidKind("Toplevel Statement", kind);
     }
 
     parseContext_->functionBox()->usesReturn = true;
 
 
     MOZ_TRY_DECL(expression, parseOptionalExpression());
 
 
-    TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start)));return result;
+    TRY_DECL(result, factory_.newReturnStatement(expression, tokenizer_->pos(start)));
+    return result;
 }
 
 
 /*
  interface Script : Node {
     AssertedVarScope? scope;
     FrozenArray<Directive> directives;
     FrozenArray<Statement> statements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseScript()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceScript(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceScript(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Scope, BinField::Directives, BinField::Statements }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Scope, BinField::Directives, BinField::Statements }));
 
 
 
     MOZ_TRY(parseOptionalAssertedVarScope());
 
 
 
 
     MOZ_TRY_DECL(directives, parseListOfDirective());
 
 
 
 
     MOZ_TRY_DECL(statements, parseListOfStatement());
 
 
-    MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));return result;
-}
-
-
-/*
- interface Setter : Node {
-    AssertedParameterScope? parameterScope;
-    AssertedVarScope? bodyScope;
-    PropertyName name;
-    Parameter param;
-    FunctionBody body;
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseSetter()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceSetter(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSetter(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    MOZ_ASSERT(kind == BinKind::Setter);
-    CheckRecursionLimit(cx_);
-
-    MOZ_TRY(checkFields(kind, fields, { BinField::ParameterScope, BinField::BodyScope, BinField::Name, BinField::Param, BinField::Body }));
-    const auto isAsync = false;
-    const auto isGenerator = false;
-    MOZ_TRY_DECL(funbox, buildFunctionBox(
-        isGenerator ? GeneratorKind::Generator
-                    : GeneratorKind::NotGenerator,
-        isAsync ? FunctionAsyncKind::AsyncFunction
-                : FunctionAsyncKind::SyncFunction));
-
-    // Push a new ParseContext. It will be used to parse `scope`, the arguments, the function.
-    BinParseContext funpc(cx_, this, funbox, /* newDirectives = */ nullptr);
-    TRY(funpc.init());
-    parseContext_->functionScope().useAsVarScope(parseContext_);
-    MOZ_ASSERT(parseContext_->isFunctionBox());
-
-    ParseContext::Scope lexicalScope(cx_, parseContext_, usedNames_);
-    TRY(lexicalScope.init(parseContext_));
-
-    MOZ_TRY(parseOptionalAssertedParameterScope());
-
-
-
-
-    MOZ_TRY(parseOptionalAssertedVarScope());
-
-
-
-
-    MOZ_TRY_DECL(name, parsePropertyName());
-
-
-
-
-    MOZ_TRY_DECL(param, parseParameter());
-
-
-
-
-    MOZ_TRY_DECL(body, parseFunctionBody());
-
-
-    TRY_DECL(params, factory_.newList(ParseNodeKind::ParamsBody, param));
-    MOZ_TRY_DECL(method, buildFunction(start, kind, name, params, body, funbox));
-    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, method, AccessorType::Setter));return result;
+    MOZ_TRY_DECL(result, appendDirectivesToBody(/* body = */ statements, /* directives = */ directives));
+    return result;
 }
 
 
 /*
  interface ShorthandProperty : Node {
     IdentifierExpression name;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseShorthandProperty()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceShorthandProperty(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceShorthandProperty(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceShorthandProperty(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ShorthandProperty);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Name }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Name }));
 
 
 
     MOZ_TRY_DECL(name, parseIdentifierExpression());
 
 
     if (!factory_.isUsableAsObjectPropertyName(name))
         TRY_VAR(name, factory_.newObjectLiteralPropertyName(name->name(), tokenizer_->pos(start)));
 
-    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None));return result;
+    TRY_DECL(result, factory_.newObjectMethodOrPropertyDefinition(name, name, AccessorType::None));
+    return result;
+}
+
+
+/*
+ interface SkippableArrowExpression : Node {
+    EagerArrowExpression skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableArrowExpression)");
+}
+
+
+/*
+ interface SkippableFunctionDeclaration : Node {
+    EagerFunctionDeclaration skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableFunctionDeclaration)");
+}
+
+
+/*
+ interface SkippableFunctionExpression : Node {
+    EagerFunctionExpression skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableFunctionExpression)");
+}
+
+
+/*
+ interface SkippableGetter : Node {
+    EagerGetter skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableGetter)");
+}
+
+
+/*
+ interface SkippableMethod : Node {
+    EagerMethod skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableMethod)");
+}
+
+
+/*
+ interface SkippableSetter : Node {
+    EagerSetter skipped;
+ }
+*/
+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();
+
+    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)
+{
+    return raiseError("FIXME: Not implemented yet (SkippableSetter)");
 }
 
 
 /*
  interface SpreadElement : Node {
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSpreadElement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSpreadElement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSpreadElement(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (SpreadElement)");
 }
 
 
 /*
  interface StaticMemberAssignmentTarget : Node {
     (Expression or Super) object;
     IdentifierName property;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseStaticMemberAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceStaticMemberAssignmentTarget(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceStaticMemberAssignmentTarget(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::StaticMemberAssignmentTarget);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Object, BinField::Property }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Property }));
 
 
 
     MOZ_TRY_DECL(object, parseExpressionOrSuper());
 
 
 
     RootedAtom property(cx_);
-    MOZ_TRY(readString(&property));
-
-
-    TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));return result;
+    MOZ_TRY_VAR(property, tokenizer_->readAtom());
+
+
+    TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));
+    return result;
 }
 
 
 /*
  interface StaticMemberExpression : Node {
     (Expression or Super) object;
     IdentifierName property;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseStaticMemberExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceStaticMemberExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceStaticMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceStaticMemberExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::StaticMemberExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Object, BinField::Property }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Property }));
 
 
 
     MOZ_TRY_DECL(object, parseExpressionOrSuper());
 
 
 
     RootedAtom property(cx_);
-    MOZ_TRY(readString(&property));
-
-
-    TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));return result;
+    MOZ_TRY_VAR(property, tokenizer_->readAtom());
+
+
+    TRY_DECL(result, factory_.newPropertyAccess(object, property->asPropertyName(), start));
+    return result;
 }
 
 
 /*
  interface Super : Node {
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSuper()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSuper(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSuper(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (Super)");
 }
 
 
 /*
  interface SwitchCase : Node {
     Expression test;
     FrozenArray<Statement> consequent;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSwitchCase()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSwitchCase(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSwitchCase(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceSwitchCase(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::SwitchCase);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Test, BinField::Consequent }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Consequent }));
 
 
 
     MOZ_TRY_DECL(test, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(consequent, parseListOfStatement());
 
 
-    TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent));return result;
+    TRY_DECL(result, factory_.newCaseOrDefault(start, test, consequent));
+    return result;
 }
 
 
 /*
  interface SwitchDefault : Node {
     FrozenArray<Statement> consequent;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSwitchDefault()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSwitchDefault(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSwitchDefault(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceSwitchDefault(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::SwitchDefault);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Consequent }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Consequent }));
 
 
 
     MOZ_TRY_DECL(consequent, parseListOfStatement());
 
 
-    TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent));return result;
+    TRY_DECL(result, factory_.newCaseOrDefault(start, nullptr, consequent));
+    return result;
 }
 
 
 /*
  interface SwitchStatement : Node {
     Expression discriminant;
     FrozenArray<SwitchCase> cases;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSwitchStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSwitchStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSwitchStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceSwitchStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::SwitchStatement);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Discriminant, BinField::Cases }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Discriminant, BinField::Cases }));
 
 
 
     MOZ_TRY_DECL(discriminant, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(cases, parseListOfSwitchCase());
 
 
     TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases));
-    TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope));return result;
+    TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope));
+    return result;
 }
 
 
 /*
  interface SwitchStatementWithDefault : Node {
     Expression discriminant;
     FrozenArray<SwitchCase> preDefaultCases;
     SwitchDefault defaultCase;
     FrozenArray<SwitchCase> postDefaultCases;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseSwitchStatementWithDefault()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceSwitchStatementWithDefault(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceSwitchStatementWithDefault(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceSwitchStatementWithDefault(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::SwitchStatementWithDefault);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Discriminant, BinField::PreDefaultCases, BinField::DefaultCase, BinField::PostDefaultCases }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Discriminant, BinField::PreDefaultCases, BinField::DefaultCase, BinField::PostDefaultCases }));
 
 
 
     MOZ_TRY_DECL(discriminant, parseExpression());
 
 
 
 
@@ -5908,233 +6281,237 @@ BinASTParser::parseInterfaceSwitchStatem
     factory_.addList(cases, defaultCase);
     ParseNode* iter = postDefaultCases->pn_head;
     while (iter) {
         ParseNode* next = iter->pn_next;
         factory_.addList(cases, iter);
         iter = next;
     }
     TRY_DECL(scope, factory_.newLexicalScope(nullptr, cases));
-    TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope));return result;
+    TRY_DECL(result, factory_.newSwitchStatement(start, discriminant, scope));
+    return result;
 }
 
 
 /*
  interface TemplateElement : Node {
     string rawValue;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseTemplateElement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceTemplateElement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceTemplateElement(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (TemplateElement)");
 }
 
 
 /*
  interface TemplateExpression : Node {
     Expression? tag;
     FrozenArray<(Expression or TemplateElement)> elements;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseTemplateExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceTemplateExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceTemplateExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (TemplateExpression)");
 }
 
 
 /*
  interface ThisExpression : Node {
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseThisExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceThisExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceThisExpression(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields0(kind, fields));
+    MOZ_TRY(tokenizer_->checkFields0(kind, fields));
 
     if (parseContext_->isFunctionBox())
         parseContext_->functionBox()->usesThis = true;
 
     TokenPos pos = tokenizer_->pos(start);
     ParseNode* thisName(nullptr);
     if (parseContext_->sc()->thisBinding() == ThisBinding::Function)
         TRY_VAR(thisName, factory_.newName(cx_->names().dotThis, pos, cx_));
 
-    TRY_DECL(result, factory_.newThisLiteral(pos, thisName));return result;
+    TRY_DECL(result, factory_.newThisLiteral(pos, thisName));
+    return result;
 }
 
 
 /*
  interface ThrowStatement : Node {
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseThrowStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceThrowStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceThrowStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceThrowStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::ThrowStatement);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Expression }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Expression }));
 
 
 
     MOZ_TRY_DECL(expression, parseExpression());
 
 
-    TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start)));return result;
+    TRY_DECL(result, factory_.newThrowStatement(expression, tokenizer_->pos(start)));
+    return result;
 }
 
 
 /*
  interface TryCatchStatement : Node {
     Block body;
     CatchClause catchClause;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseTryCatchStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceTryCatchStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceTryCatchStatement(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Body, BinField::CatchClause }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Body, BinField::CatchClause }));
 
     ParseNode* body;
     {
         ParseContext::Statement stmt(parseContext_, StatementKind::Try);
         ParseContext::Scope scope(cx_, parseContext_, usedNames_);
         TRY(scope.init(parseContext_));
         MOZ_TRY_VAR(body, parseBlock());
 
     }
 
 
 
     MOZ_TRY_DECL(catchClause, parseCatchClause());
 
 
-    TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr));return result;
+    TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, /* finally = */ nullptr));
+    return result;
 }
 
 
 /*
  interface TryFinallyStatement : Node {
     Block body;
     CatchClause? catchClause;
     Block finalizer;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseTryFinallyStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceTryFinallyStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceTryFinallyStatement(const size_t start, const BinKind kind, const BinFields& 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);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Body, BinField::CatchClause, BinField::Finalizer }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Body, BinField::CatchClause, BinField::Finalizer }));
 
     ParseNode* body;
     {
         ParseContext::Statement stmt(parseContext_, StatementKind::Try);
         ParseContext::Scope scope(cx_, parseContext_, usedNames_);
         TRY(scope.init(parseContext_));
         MOZ_TRY_VAR(body, parseBlock());
 
@@ -6149,49 +6526,50 @@ BinASTParser::parseInterfaceTryFinallySt
     {
         ParseContext::Statement stmt(parseContext_, StatementKind::Finally);
         ParseContext::Scope scope(cx_, parseContext_, usedNames_);
         TRY(scope.init(parseContext_));
         MOZ_TRY_VAR(finalizer, parseBlock());
 
     }
 
-    TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer));return result;
+    TRY_DECL(result, factory_.newTryStatement(start, body, catchClause, finalizer));
+    return result;
 }
 
 
 /*
  interface UnaryExpression : Node {
     UnaryOperator operator;
     Expression operand;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseUnaryExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceUnaryExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceUnaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceUnaryExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::UnaryExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Operator, BinField::Operand }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Operator, BinField::Operand }));
 
 
 
     MOZ_TRY_DECL(operator_, parseUnaryOperator());
 
 
 
 
@@ -6235,54 +6613,55 @@ BinASTParser::parseInterfaceUnaryExpress
             pnk = ParseNodeKind::DeleteElem;
             break;
           default:
             pnk = ParseNodeKind::DeleteExpr;
         }
         break;
       }
     }
-    TRY_DECL(result, factory_.newUnary(pnk, start, operand));return result;
+    TRY_DECL(result, factory_.newUnary(pnk, start, operand));
+    return result;
 }
 
 
 /*
  interface UpdateExpression : Node {
     bool isPrefix;
     UpdateOperator operator;
     SimpleAssignmentTarget operand;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseUpdateExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceUpdateExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceUpdateExpression(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceUpdateExpression(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::UpdateExpression);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::IsPrefix, BinField::Operator, BinField::Operand }));
-
-
-
-    MOZ_TRY_DECL(isPrefix, readBool());
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::IsPrefix, BinField::Operator, BinField::Operand }));
+
+
+
+    MOZ_TRY_DECL(isPrefix, tokenizer_->readBool());
 
 
 
 
     MOZ_TRY_DECL(operator_, parseUpdateOperator());
 
 
 
@@ -6296,49 +6675,50 @@ BinASTParser::parseInterfaceUpdateExpres
         pnk = isPrefix ? ParseNodeKind::PreIncrement
                        : ParseNodeKind::PostIncrement;
         break;
       case UpdateOperator::Decr:
         pnk = isPrefix ? ParseNodeKind::PreDecrement
                        : ParseNodeKind::PostDecrement;
         break;
     }
-    TRY_DECL(result, factory_.newUnary(pnk, start, operand));return result;
+    TRY_DECL(result, factory_.newUnary(pnk, start, operand));
+    return result;
 }
 
 
 /*
  interface VariableDeclaration : Node {
     VariableDeclarationKind kind;
     FrozenArray<VariableDeclarator> declarators;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseVariableDeclaration()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceVariableDeclaration(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceVariableDeclaration(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::VariableDeclaration);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Kind, BinField::Declarators }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Kind, BinField::Declarators }));
     AutoVariableDeclarationKind kindGuard(this);
 
 
     MOZ_TRY_DECL(kind_, parseVariableDeclarationKind());
     // Restored by `kindGuard`.
     variableDeclarationKind_ = kind_;
 
 
@@ -6358,49 +6738,50 @@ BinASTParser::parseInterfaceVariableDecl
       case VariableDeclarationKind::Let:
         pnk = ParseNodeKind::Let;
         break;
       case VariableDeclarationKind::Const:
         pnk = ParseNodeKind::Const;
         break;
     }
     declarators->setKind(pnk);
-    auto result = declarators;return result;
+    auto result = declarators;
+    return result;
 }
 
 
 /*
  interface VariableDeclarator : Node {
     Binding binding;
     Expression? init;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseVariableDeclarator()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceVariableDeclarator(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceVariableDeclarator(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceVariableDeclarator(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::VariableDeclarator);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Binding, BinField::Init }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Binding, BinField::Init }));
 
 
 
     MOZ_TRY_DECL(binding, parseBinding());
 
 
 
 
@@ -6419,191 +6800,167 @@ BinASTParser::parseInterfaceVariableDecl
         // `var pattern = bar`
         if (!init) {
             // Here, `init` is required.
             return raiseMissingField("VariableDeclarator (with non-trivial pattern)", BinField::Init);
         }
 
         MOZ_CRASH("Unimplemented: AssertedScope check for BindingPattern variable declaration");
         TRY_VAR(result, factory_.newAssignment(ParseNodeKind::Assign, binding, init));
-    }return result;
+    }
+    return result;
 }
 
 
 /*
  interface WhileStatement : Node {
     Expression test;
     Statement body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseWhileStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceWhileStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceWhileStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::WhileStatement);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Test, BinField::Body }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Test, BinField::Body }));
     ParseContext::Statement stmt(parseContext_, StatementKind::WhileLoop);
 
 
     MOZ_TRY_DECL(test, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(body, parseStatement());
 
 
-    TRY_DECL(result, factory_.newWhileStatement(start, test, body));return result;
+    TRY_DECL(result, factory_.newWhileStatement(start, test, body));
+    return result;
 }
 
 
 /*
  interface WithStatement : Node {
     Expression object;
     Statement body;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseWithStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceWithStatement(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceWithStatement(const size_t start, const BinKind kind, const BinFields& fields)
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseInterfaceWithStatement(const size_t start, const BinKind kind, const BinFields& fields)
 {
     MOZ_ASSERT(kind == BinKind::WithStatement);
     CheckRecursionLimit(cx_);
 
-    MOZ_TRY(checkFields(kind, fields, { BinField::Object, BinField::Body }));
+    MOZ_TRY(tokenizer_->checkFields(kind, fields, { BinField::Object, BinField::Body }));
 
 
 
     MOZ_TRY_DECL(object, parseExpression());
 
 
 
 
     MOZ_TRY_DECL(body, parseStatement());
 
 
-    TRY_DECL(result, factory_.newWithStatement(start, object, body));return result;
+    TRY_DECL(result, factory_.newWithStatement(start, object, body));
+    return result;
 }
 
 
 /*
  interface YieldExpression : Node {
     Expression? expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseYieldExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceYieldExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceYieldExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (YieldExpression)");
 }
 
 
 /*
  interface YieldStarExpression : Node {
     Expression expression;
  }
 */
-JS::Result<ParseNode*>
-BinASTParser::parseYieldStarExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+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();
 
     MOZ_TRY_DECL(result, parseInterfaceYieldStarExpression(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceYieldStarExpression(const size_t start, const BinKind kind, const BinFields& 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)
 {
     return raiseError("FIXME: Not implemented yet (YieldStarExpression)");
 }
 
 
-/*
- interface _Null : Node {
- }
-*/
-JS::Result<ParseNode*>
-BinASTParser::parseNull()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
-    const auto start = tokenizer_->offset();
-
-    MOZ_TRY_DECL(result, parseInterfaceNull(start, kind, fields));
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseInterfaceNull(const size_t start, const BinKind kind, const BinFields& fields)
-{
-    return raiseError("FIXME: Not implemented yet (Null)");
-}
-
-
 
 // ----- String enums (autogenerated, by lexicographical order)
 /*
 enum BinaryOperator {
     ",",
     "||",
     "&&",
     "|",
@@ -6625,75 +6982,75 @@ enum BinaryOperator {
     "+",
     "-",
     "*",
     "/",
     "%",
     "**"
 };
 */
-JS::Result<BinASTParser::BinaryOperator>
-BinASTParser::parseBinaryOperator()
-{
-    // Unoptimized implementation.
-    Chars chars(cx_);
-    MOZ_TRY(readString(chars));
-
-    if (chars == ",")
+template<typename Tok> JS::Result<typename BinASTParser<Tok>::BinaryOperator>
+BinASTParser<Tok>::parseBinaryOperator()
+{
+    MOZ_TRY_DECL(variant, tokenizer_->readVariant());
+
+    switch (variant) {
+    case BinVariant::BinaryOperatorComma:
         return BinaryOperator::Comma;
-    if (chars == "||")
+    case BinVariant::BinaryOperatorLogicalOr:
         return BinaryOperator::LogicalOr;
-    if (chars == "&&")
+    case BinVariant::BinaryOperatorLogicalAnd:
         return BinaryOperator::LogicalAnd;
-    if (chars == "|")
+    case BinVariant::BinaryOperatorBitOr:
         return BinaryOperator::BitOr;
-    if (chars == "^")
+    case BinVariant::BinaryOperatorBitXor:
         return BinaryOperator::BitXor;
-    if (chars == "&")
+    case BinVariant::BinaryOperatorBitAnd:
         return BinaryOperator::BitAnd;
-    if (chars == "==")
+    case BinVariant::BinaryOperatorEq:
         return BinaryOperator::Eq;
-    if (chars == "!=")
+    case BinVariant::BinaryOperatorNeq:
         return BinaryOperator::Neq;
-    if (chars == "===")
+    case BinVariant::BinaryOperatorStrictEq:
         return BinaryOperator::StrictEq;
-    if (chars == "!==")
+    case BinVariant::BinaryOperatorStrictNeq:
         return BinaryOperator::StrictNeq;
-    if (chars == "<")
+    case BinVariant::BinaryOperatorLessThan:
         return BinaryOperator::LessThan;
-    if (chars == "<=")
+    case BinVariant::BinaryOperatorLeqThan:
         return BinaryOperator::LeqThan;
-    if (chars == ">")
+    case BinVariant::BinaryOperatorGreaterThan:
         return BinaryOperator::GreaterThan;
-    if (chars == ">=")
+    case BinVariant::BinaryOperatorGeqThan:
         return BinaryOperator::GeqThan;
-    if (chars == "in")
+    case BinVariant::BinaryOperatorIn:
         return BinaryOperator::In;
-    if (chars == "instanceof")
+    case BinVariant::BinaryOperatorInstanceof:
         return BinaryOperator::Instanceof;
-    if (chars == "<<")
+    case BinVariant::BinaryOperatorLsh:
         return BinaryOperator::Lsh;
-    if (chars == ">>")
+    case BinVariant::BinaryOperatorRsh:
         return BinaryOperator::Rsh;
-    if (chars == ">>>")
+    case BinVariant::BinaryOperatorUrsh:
         return BinaryOperator::Ursh;
-    if (chars == "+")
+    case BinVariant::BinaryOperatorOrUnaryOperatorPlus:
         return BinaryOperator::Plus;
-    if (chars == "-")
+    case BinVariant::BinaryOperatorOrUnaryOperatorMinus:
         return BinaryOperator::Minus;
-    if (chars == "*")
+    case BinVariant::BinaryOperatorMul:
         return BinaryOperator::Mul;
-    if (chars == "/")
+    case BinVariant::BinaryOperatorDiv:
         return BinaryOperator::Div;
-    if (chars == "%")
+    case BinVariant::BinaryOperatorMod:
         return BinaryOperator::Mod;
-    if (chars == "**")
+    case BinVariant::BinaryOperatorPow:
         return BinaryOperator::Pow;
-
-    return raiseInvalidEnum("BinaryOperator", chars);
+      default:
+        return raiseInvalidVariant("BinaryOperator", variant);
+    }
 }
 
 /*
 enum CompoundAssignmentOperator {
     "+=",
     "-=",
     "*=",
     "/=",
@@ -6702,624 +7059,631 @@ enum CompoundAssignmentOperator {
     "<<=",
     ">>=",
     ">>>=",
     "|=",
     "^=",
     "&="
 };
 */
-JS::Result<BinASTParser::CompoundAssignmentOperator>
-BinASTParser::parseCompoundAssignmentOperator()
-{
-    // Unoptimized implementation.
-    Chars chars(cx_);
-    MOZ_TRY(readString(chars));
-
-    if (chars == "+=")
+template<typename Tok> JS::Result<typename BinASTParser<Tok>::CompoundAssignmentOperator>
+BinASTParser<Tok>::parseCompoundAssignmentOperator()
+{
+    MOZ_TRY_DECL(variant, tokenizer_->readVariant());
+
+    switch (variant) {
+    case BinVariant::CompoundAssignmentOperatorPlusAssign:
         return CompoundAssignmentOperator::PlusAssign;
-    if (chars == "-=")
+    case BinVariant::CompoundAssignmentOperatorMinusAssign:
         return CompoundAssignmentOperator::MinusAssign;
-    if (chars == "*=")
+    case BinVariant::CompoundAssignmentOperatorMulAssign:
         return CompoundAssignmentOperator::MulAssign;
-    if (chars == "/=")
+    case BinVariant::CompoundAssignmentOperatorDivAssign:
         return CompoundAssignmentOperator::DivAssign;
-    if (chars == "%=")
+    case BinVariant::CompoundAssignmentOperatorModAssign:
         return CompoundAssignmentOperator::ModAssign;
-    if (chars == "**=")
+    case BinVariant::CompoundAssignmentOperatorPowAssign:
         return CompoundAssignmentOperator::PowAssign;
-    if (chars == "<<=")
+    case BinVariant::CompoundAssignmentOperatorLshAssign:
         return CompoundAssignmentOperator::LshAssign;
-    if (chars == ">>=")
+    case BinVariant::CompoundAssignmentOperatorRshAssign:
         return CompoundAssignmentOperator::RshAssign;
-    if (chars == ">>>=")
+    case BinVariant::CompoundAssignmentOperatorUrshAssign:
         return CompoundAssignmentOperator::UrshAssign;
-    if (chars == "|=")
+    case BinVariant::CompoundAssignmentOperatorBitOrAssign:
         return CompoundAssignmentOperator::BitOrAssign;
-    if (chars == "^=")
+    case BinVariant::CompoundAssignmentOperatorBitXorAssign:
         return CompoundAssignmentOperator::BitXorAssign;
-    if (chars == "&=")
+    case BinVariant::CompoundAssignmentOperatorBitAndAssign:
         return CompoundAssignmentOperator::BitAndAssign;
-
-    return raiseInvalidEnum("CompoundAssignmentOperator", chars);
+      default:
+        return raiseInvalidVariant("CompoundAssignmentOperator", variant);
+    }
 }
 
 /*
 enum UnaryOperator {
     "+",
     "-",
     "!",
     "~",
     "typeof",
     "void",
     "delete"
 };
 */
-JS::Result<BinASTParser::UnaryOperator>
-BinASTParser::parseUnaryOperator()
-{
-    // Unoptimized implementation.
-    Chars chars(cx_);
-    MOZ_TRY(readString(chars));
-
-    if (chars == "+")
+template<typename Tok> JS::Result<typename BinASTParser<Tok>::UnaryOperator>
+BinASTParser<Tok>::parseUnaryOperator()
+{
+    MOZ_TRY_DECL(variant, tokenizer_->readVariant());
+
+    switch (variant) {
+    case BinVariant::BinaryOperatorOrUnaryOperatorPlus:
         return UnaryOperator::Plus;
-    if (chars == "-")
+    case BinVariant::BinaryOperatorOrUnaryOperatorMinus:
         return UnaryOperator::Minus;
-    if (chars == "!")
+    case BinVariant::UnaryOperatorNot:
         return UnaryOperator::Not;
-    if (chars == "~")
+    case BinVariant::UnaryOperatorBitNot:
         return UnaryOperator::BitNot;
-    if (chars == "typeof")
+    case BinVariant::UnaryOperatorTypeof:
         return UnaryOperator::Typeof;
-    if (chars == "void")
+    case BinVariant::UnaryOperatorVoid:
         return UnaryOperator::Void;
-    if (chars == "delete")
+    case BinVariant::UnaryOperatorDelete:
         return UnaryOperator::Delete;
-
-    return raiseInvalidEnum("UnaryOperator", chars);
+      default:
+        return raiseInvalidVariant("UnaryOperator", variant);
+    }
 }
 
 /*
 enum UpdateOperator {
     "++",
     "--"
 };
 */
-JS::Result<BinASTParser::UpdateOperator>
-BinASTParser::parseUpdateOperator()
-{
-    // Unoptimized implementation.
-    Chars chars(cx_);
-    MOZ_TRY(readString(chars));
-
-    if (chars == "++")
+template<typename Tok> JS::Result<typename BinASTParser<Tok>::UpdateOperator>
+BinASTParser<Tok>::parseUpdateOperator()
+{
+    MOZ_TRY_DECL(variant, tokenizer_->readVariant());
+
+    switch (variant) {
+    case BinVariant::UpdateOperatorIncr:
         return UpdateOperator::Incr;
-    if (chars == "--")
+    case BinVariant::UpdateOperatorDecr:
         return UpdateOperator::Decr;
-
-    return raiseInvalidEnum("UpdateOperator", chars);
+      default:
+        return raiseInvalidVariant("UpdateOperator", variant);
+    }
 }
 
 /*
 enum VariableDeclarationKind {
     "var",
     "let",
     "const"
 };
 */
-JS::Result<BinASTParser::VariableDeclarationKind>
-BinASTParser::parseVariableDeclarationKind()
-{
-    // Unoptimized implementation.
-    Chars chars(cx_);
-    MOZ_TRY(readString(chars));
-
-    if (chars == "var")
+template<typename Tok> JS::Result<typename BinASTParser<Tok>::VariableDeclarationKind>
+BinASTParser<Tok>::parseVariableDeclarationKind()
+{
+    MOZ_TRY_DECL(variant, tokenizer_->readVariant());
+
+    switch (variant) {
+    case BinVariant::VariableDeclarationKindVar:
         return VariableDeclarationKind::Var;
-    if (chars == "let")
+    case BinVariant::VariableDeclarationKindLet:
         return VariableDeclarationKind::Let;
-    if (chars == "const")
+    case BinVariant::VariableDeclarationKindConst:
         return VariableDeclarationKind::Const;
-
-    return raiseInvalidEnum("VariableDeclarationKind", chars);
+      default:
+        return raiseInvalidVariant("VariableDeclarationKind", variant);
+    }
 }
 
 
 
 // ----- Lists (autogenerated, by lexicographical order)
 
-JS::Result<ParseNode*>
-BinASTParser::parseArguments()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseArguments()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newList(ParseNodeKind::ParamsBody, tokenizer_->pos(start)));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseSpreadElementOrExpression());
         factory_.addList(/* list = */ result, /* child = */ item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfAssignmentTargetOrAssignmentTargetWithInitializer()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfAssignmentTargetOrAssignmentTargetWithInitializer()
 {
     return raiseError("FIXME: Not implemented yet (ListOfAssignmentTargetOrAssignmentTargetWithInitializer)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfAssignmentTargetProperty()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfAssignmentTargetProperty()
 {
     return raiseError("FIXME: Not implemented yet (ListOfAssignmentTargetProperty)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfBindingProperty()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfBindingProperty()
 {
     return raiseError("FIXME: Not implemented yet (ListOfBindingProperty)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfClassElement()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfClassElement()
 {
     return raiseError("FIXME: Not implemented yet (ListOfClassElement)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfDirective()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfDirective()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start)));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseDirective());
         factory_.addStatementToList(result, item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfExportFromSpecifier()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfExportFromSpecifier()
 {
     return raiseError("FIXME: Not implemented yet (ListOfExportFromSpecifier)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfExportLocalSpecifier()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfExportLocalSpecifier()
 {
     return raiseError("FIXME: Not implemented yet (ListOfExportLocalSpecifier)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfExpressionOrTemplateElement()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfExpressionOrTemplateElement()
 {
     return raiseError("FIXME: Not implemented yet (ListOfExpressionOrTemplateElement)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfIdentifierName()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfIdentifierName()
 {
     return raiseError("FIXME: Not implemented yet (ListOfIdentifierName)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfImportDeclarationOrExportDeclarationOrStatement()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfImportDeclarationOrExportDeclarationOrStatement()
 {
     return raiseError("FIXME: Not implemented yet (ListOfImportDeclarationOrExportDeclarationOrStatement)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfImportSpecifier()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfImportSpecifier()
 {
     return raiseError("FIXME: Not implemented yet (ListOfImportSpecifier)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfObjectProperty()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfObjectProperty()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newObjectLiteral(start));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseObjectProperty());
         result->appendWithoutOrderAssumption(item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfOptionalBindingOrBindingWithInitializer()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfOptionalBindingOrBindingWithInitializer()
 {
     return raiseError("FIXME: Not implemented yet (ListOfOptionalBindingOrBindingWithInitializer)");
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseListOfOptionalSpreadElementOrExpression()
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfOptionalSpreadElementOrExpression()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newArrayLiteral(start));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseOptionalSpreadElementOrExpression());
         if (item)
             factory_.addArrayElement(result, item); // Infallible.
         else
             TRY(factory_.addElision(result, tokenizer_->pos(start)));
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfParameter()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfParameter()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     ParseNode* result = new_<ListNode>(ParseNodeKind::ParamsBody, tokenizer_->pos(start));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseParameter());
         factory_.addList(/* list = */ result, /* item = */ item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfStatement()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfStatement()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start)));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseStatement());
         factory_.addStatementToList(result, item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfSwitchCase()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfSwitchCase()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newStatementList(tokenizer_->pos(start)));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseSwitchCase());
         factory_.addCaseStatementToList(result, item);
     }
 
-    TRY(guard.done());
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseListOfVariableDeclarator()
+    MOZ_TRY(guard.done());
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseListOfVariableDeclarator()
 {
     uint32_t length;
     AutoList guard(*tokenizer_);
 
     const auto start = tokenizer_->offset();
-    TRY(tokenizer_->enterList(length, guard));
+    MOZ_TRY(tokenizer_->enterList(length, guard));
     TRY_DECL(result, factory_.newDeclarationList(ParseNodeKind::Const /*Placeholder*/,
         tokenizer_->pos(start)));
 
     for (uint32_t i = 0; i < length; ++i) {
         MOZ_TRY_DECL(item, parseVariableDeclarator());
         result->appendWithoutOrderAssumption(item);
     }
 
-    TRY(guard.done());
+    MOZ_TRY(guard.done());
     return result;
 }
 
 
     // ----- Default values (by lexicographical order)
-JS::Result<Ok>
-BinASTParser::parseOptionalAssertedBlockScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<Ok>
+BinASTParser<Tok>::parseOptionalAssertedBlockScope()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     Ok result;
     if (kind == BinKind::_Null) {
         result = Ok();
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseInterfaceAssertedBlockScope(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<Ok>
-BinASTParser::parseOptionalAssertedParameterScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<Ok>
+BinASTParser<Tok>::parseOptionalAssertedParameterScope()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     Ok result;
     if (kind == BinKind::_Null) {
         result = Ok();
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseInterfaceAssertedParameterScope(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<Ok>
-BinASTParser::parseOptionalAssertedVarScope()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<Ok>
+BinASTParser<Tok>::parseOptionalAssertedVarScope()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     Ok result;
     if (kind == BinKind::_Null) {
         result = Ok();
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseInterfaceAssertedVarScope(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalAssignmentTarget()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalAssignmentTarget()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumAssignmentTarget(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalBinding()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalBinding()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumBinding(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalBindingIdentifier()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalBindingIdentifier()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseInterfaceBindingIdentifier(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalBindingOrBindingWithInitializer()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalBindingOrBindingWithInitializer()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumBindingOrBindingWithInitializer(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalCatchClause()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalCatchClause()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseInterfaceCatchClause(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumExpression(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalIdentifierName()
-{
-    RootedAtom string(cx_);
-    MOZ_TRY(readMaybeString(&string));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalIdentifierName()
+{
+    MOZ_TRY_DECL(result, tokenizer_->readMaybeAtom());
 
 
 
     return raiseError("FIXME: Not implemented yet (OptionalIdentifierName)");
 
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalLabel()
-{
-    RootedAtom string(cx_);
-    MOZ_TRY(readMaybeString(&string));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalLabel()
+{
+    MOZ_TRY_DECL(result, tokenizer_->readMaybeAtom());
 
 
 
     return raiseError("FIXME: Not implemented yet (OptionalLabel)");
 
 }
 
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalSpreadElementOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalSpreadElementOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumSpreadElementOrExpression(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalStatement()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalStatement()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumStatement(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-JS::Result<ParseNode*>
-BinASTParser::parseOptionalVariableDeclarationOrExpression()
-{
-    BinKind kind;
-    BinFields fields(cx_);
-    AutoTaggedTuple guard(*tokenizer_);
-
-    TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+template<typename Tok> JS::Result<ParseNode*>
+BinASTParser<Tok>::parseOptionalVariableDeclarationOrExpression()
+{
+    BinKind kind;
+    BinFields fields(cx_);
+    AutoTaggedTuple guard(*tokenizer_);
+
+    MOZ_TRY(tokenizer_->enterTaggedTuple(kind, fields, guard));
     ParseNode* result;
     if (kind == BinKind::_Null) {
         result = nullptr;
     } else {
         const auto start = tokenizer_->offset();
         MOZ_TRY_VAR(result, parseSumVariableDeclarationOrExpression(start, kind, fields));
     }
-    TRY(guard.done());
-
-    return result;
-}
-
-
+    MOZ_TRY(guard.done());
+
+    return result;
+}
+
+
+
+// Force class instantiation.
+// This ensures that the symbols are built, without having to export all our
+// code (and its baggage of #include and macros) in the header.
+template class BinASTParser<BinTokenReaderMultipart>;
+template class BinASTParser<BinTokenReaderTester>;
+
+} // namespace frontend
+} // namespace js
 
 #undef TRY
 #undef TRY_VAR
 #undef TRY_DECL
+#undef TRY_EMPL
+#undef MOZ_TRY_EMPLACE
 #undef MOZ_TRY_DECL
-} // namespace frontend
-} // namespace js