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