Bug 1528837 - Part 13: Rename PerHandlerParser::handler field to handler_. r=Yoric
authorTooru Fujisawa <arai_a@mac.com>
Sun, 24 Feb 2019 03:32:09 +0000
changeset 518660 f55920d58943
parent 518659 21b0cdf00414
child 518661 151271d3dfc2
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersYoric
bugs1528837
milestone67.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 1528837 - Part 13: Rename PerHandlerParser::handler field to handler_. r=Yoric Differential Revision: https://phabricator.services.mozilla.com/D20225
js/src/frontend/EitherParser.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
js/src/wasm/AsmJS.cpp
--- a/js/src/frontend/EitherParser.h
+++ b/js/src/frontend/EitherParser.h
@@ -84,17 +84,17 @@ struct TokenStreamComputeLineAndColumn {
   static constexpr auto get() { return &TokenStream::computeLineAndColumn; }
 };
 
 // Generic matchers.
 
 struct ParseHandlerMatcher {
   template <class Parser>
   frontend::FullParseHandler& match(Parser* parser) {
-    return parser->handler;
+    return parser->handler_;
   }
 };
 
 struct ParserBaseMatcher {
   template <class Parser>
   frontend::ParserBase& match(Parser* parser) {
     return *static_cast<frontend::ParserBase*>(parser);
   }
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -187,17 +187,17 @@ ParserBase::~ParserBase() {
 template <class ParseHandler>
 PerHandlerParser<ParseHandler>::PerHandlerParser(
     JSContext* cx, LifoAlloc& alloc, const ReadOnlyCompileOptions& options,
     bool foldConstants, UsedNameTracker& usedNames,
     LazyScript* lazyOuterFunction, ScriptSourceObject* sourceObject,
     ParseGoal parseGoal, void* internalSyntaxParser)
     : ParserBase(cx, alloc, options, foldConstants, usedNames, sourceObject,
                  parseGoal),
-      handler(cx, alloc, lazyOuterFunction),
+      handler_(cx, alloc, lazyOuterFunction),
       internalSyntaxParser_(internalSyntaxParser) {}
 
 template <class ParseHandler, typename Unit>
 GeneralParser<ParseHandler, Unit>::GeneralParser(
     JSContext* cx, LifoAlloc& alloc, const ReadOnlyCompileOptions& options,
     const Unit* units, size_t length, bool foldConstants,
     UsedNameTracker& usedNames, SyntaxParser* syntaxParser,
     LazyScript* lazyOuterFunction, ScriptSourceObject* sourceObject,
@@ -298,17 +298,17 @@ FunctionBox* PerHandlerParser<ParseHandl
       options().extraWarningsOption, generatorKind, asyncKind);
   if (!funbox) {
     ReportOutOfMemory(cx_);
     return nullptr;
   }
 
   traceListHead_ = funbox;
   if (funNode) {
-    handler.setFunctionBox(funNode, funbox);
+    handler_.setFunctionBox(funNode, funbox);
   }
 
   return funbox;
 }
 
 void ParserBase::trace(JSTracer* trc) {
   TraceListNode::TraceList(trc, traceListHead_);
 }
@@ -391,21 +391,21 @@ typename ParseHandler::ListNodeType Gene
     error(JSMSG_GARBAGE_AFTER_INPUT, "script", TokenKindToDesc(tt));
     return null();
   }
   if (foldConstants_) {
     Node node = stmtList;
     // Don't constant-fold inside "use asm" code, as this could create a parse
     // tree that doesn't type-check as asm.js.
     if (!pc_->useAsmOrInsideUseAsm()) {
-      if (!FoldConstants(cx_, &node, &handler)) {
-        return null();
-      }
-    }
-    stmtList = handler.asList(node);
+      if (!FoldConstants(cx_, &node, &handler_)) {
+        return null();
+      }
+    }
+    stmtList = handler_.asList(node);
   }
 
   return stmtList;
 }
 
 /*
  * Strict mode forbids introducing new definitions for 'eval', 'arguments',
  * 'let', 'static', 'yield', or for any strict mode reserved word.
@@ -554,31 +554,31 @@ bool GeneralParser<ParseHandler, Unit>::
     return false;
   }
 
   NameNodeType paramNode = newName(name);
   if (!paramNode) {
     return false;
   }
 
-  handler.addFunctionFormalParameter(funNode, paramNode);
+  handler_.addFunctionFormalParameter(funNode, paramNode);
   return true;
 }
 
 template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::noteDestructuredPositionalFormalParameter(
     FunctionNodeType funNode, Node destruct) {
   // Append an empty name to the positional formals vector to keep track of
   // argument slots when making FunctionScope::Data.
   if (!pc_->positionalFormalParameterNames().append(nullptr)) {
     ReportOutOfMemory(cx_);
     return false;
   }
 
-  handler.addFunctionFormalParameter(funNode, destruct);
+  handler_.addFunctionFormalParameter(funNode, destruct);
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::
     checkLexicalDeclarationDirectlyWithinBlock(ParseContext::Statement& stmt,
                                                DeclarationKind kind,
                                                TokenPos pos) {
@@ -811,20 +811,20 @@ template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::
     propagateFreeNamesAndMarkClosedOverBindings(ParseContext::Scope& scope) {
   // Now that we have all the declared names in the scope, check which
   // functions should exhibit Annex B semantics.
   if (!scope.propagateAndMarkAnnexBFunctionBoxes(pc_)) {
     return false;
   }
 
-  if (handler.canSkipLazyClosedOverBindings()) {
+  if (handler_.canSkipLazyClosedOverBindings()) {
     // Scopes are nullptr-delimited in the LazyScript closed over bindings
     // array.
-    while (JSAtom* name = handler.nextLazyClosedOverBinding()) {
+    while (JSAtom* name = handler_.nextLazyClosedOverBinding()) {
       scope.lookupDeclaredName(name)->value()->setClosedOver();
     }
     return true;
   }
 
   bool isSyntaxParser =
       mozilla::IsSame<ParseHandler, SyntaxParseHandler>::value;
   uint32_t scriptId = pc_->scriptId();
@@ -1291,32 +1291,32 @@ Maybe<LexicalScope::Data*> ParserBase::n
 template <>
 SyntaxParseHandler::LexicalScopeNodeType
 PerHandlerParser<SyntaxParseHandler>::finishLexicalScope(
     ParseContext::Scope& scope, Node body) {
   if (!propagateFreeNamesAndMarkClosedOverBindings(scope)) {
     return null();
   }
 
-  return handler.newLexicalScope(body);
+  return handler_.newLexicalScope(body);
 }
 
 template <>
 LexicalScopeNode* PerHandlerParser<FullParseHandler>::finishLexicalScope(
     ParseContext::Scope& scope, ParseNode* body) {
   if (!propagateFreeNamesAndMarkClosedOverBindings(scope)) {
     return nullptr;
   }
 
   Maybe<LexicalScope::Data*> bindings = newLexicalScopeData(scope);
   if (!bindings) {
     return nullptr;
   }
 
-  return handler.newLexicalScope(*bindings, body);
+  return handler_.newLexicalScope(*bindings, body);
 }
 
 template <typename Unit>
 LexicalScopeNode* Parser<FullParseHandler, Unit>::evalBody(
     EvalSharedContext* evalsc) {
   SourceParseContext evalpc(this, evalsc, /* newDirectives = */ nullptr);
   if (!evalpc.init()) {
     return nullptr;
@@ -1374,21 +1374,21 @@ LexicalScopeNode* Parser<FullParseHandle
                "allows super.property");
   }
 #endif
 
   ParseNode* node = body;
   // Don't constant-fold inside "use asm" code, as this could create a parse
   // tree that doesn't type-check as asm.js.
   if (!pc_->useAsmOrInsideUseAsm()) {
-    if (!FoldConstants(cx_, &node, &handler)) {
-      return null();
-    }
-  }
-  body = handler.asLexicalScope(node);
+    if (!FoldConstants(cx_, &node, &handler_)) {
+      return null();
+    }
+  }
+  body = handler_.asLexicalScope(node);
 
   if (!this->setSourceMapInfo()) {
     return nullptr;
   }
 
   // For eval scripts, since all bindings are automatically considered
   // closed over, we don't need to call propagateFreeNamesAndMarkClosed-
   // OverBindings. However, Annex B.3.3 functions still need to be marked.
@@ -1426,17 +1426,17 @@ ListNode* Parser<FullParseHandler, Unit>
   if (!checkStatementsEOF()) {
     return nullptr;
   }
 
   ParseNode* node = body;
   // Don't constant-fold inside "use asm" code, as this could create a parse
   // tree that doesn't type-check as asm.js.
   if (!pc_->useAsmOrInsideUseAsm()) {
-    if (!FoldConstants(cx_, &node, &handler)) {
+    if (!FoldConstants(cx_, &node, &handler_)) {
       return null();
     }
   }
   body = &node->as<ListNode>();
 
   if (!this->setSourceMapInfo()) {
     return nullptr;
   }
@@ -1467,17 +1467,17 @@ ModuleNode* Parser<FullParseHandler, Uni
     return null();
   }
 
   ParseContext::VarScope varScope(this);
   if (!varScope.init(pc_)) {
     return nullptr;
   }
 
-  ModuleNodeType moduleNode = handler.newModule(pos());
+  ModuleNodeType moduleNode = handler_.newModule(pos());
   if (!moduleNode) {
     return null();
   }
 
   AutoAwaitIsKeyword<FullParseHandler, Unit> awaitIsKeyword(
       this, AwaitIsModuleKeyword);
   ListNode* stmtList = statementList(YieldIsName);
   if (!stmtList) {
@@ -1518,17 +1518,17 @@ ModuleNode* Parser<FullParseHandler, Uni
 
     p->value()->setClosedOver();
   }
 
   ParseNode* node = stmtList;
   // Don't constant-fold inside "use asm" code, as this could create a parse
   // tree that doesn't type-check as asm.js.
   if (!pc_->useAsmOrInsideUseAsm()) {
-    if (!FoldConstants(cx_, &node, &handler)) {
+    if (!FoldConstants(cx_, &node, &handler_)) {
       return null();
     }
   }
   stmtList = &node->as<ListNode>();
 
   if (!this->setSourceMapInfo()) {
     return null();
   }
@@ -1567,17 +1567,17 @@ bool PerHandlerParser<ParseHandler>::dec
   }
 
   // Derived class constructors emit JSOP_CHECKRETURN, which requires
   // '.this' to be bound.
   FunctionBox* funbox = pc_->functionBox();
   HandlePropertyName dotThis = cx_->names().dotThis;
 
   bool declareThis;
-  if (handler.canSkipLazyClosedOverBindings()) {
+  if (handler_.canSkipLazyClosedOverBindings()) {
     declareThis = funbox->function()->lazyScript()->hasThisBinding();
   } else {
     declareThis = hasUsedFunctionSpecialName(dotThis) ||
                   funbox->isDerivedClassConstructor();
   }
 
   if (declareThis) {
     ParseContext::Scope& funScope = pc_->functionScope();
@@ -1807,22 +1807,22 @@ FunctionNode* Parser<FullParseHandler, U
   if (TokenKindIsPossibleIdentifierName(tt)) {
     MOZ_ASSERT(anyChars.currentName() == fun->explicitName());
   } else {
     MOZ_ASSERT(fun->explicitName() == nullptr);
     anyChars.ungetToken();
   }
 
   FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Statement;
-  FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(syntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
-  ListNodeType argsbody = handler.newList(ParseNodeKind::ParamsBody, pos());
+  ListNodeType argsbody = handler_.newList(ParseNodeKind::ParamsBody, pos());
   if (!argsbody) {
     return null();
   }
   funNode->setBody(argsbody);
 
   FunctionBox* funbox =
       newFunctionBox(funNode, fun, /* toStringStart = */ 0, inheritedDirectives,
                      generatorKind, asyncKind);
@@ -1854,17 +1854,17 @@ FunctionNode* Parser<FullParseHandler, U
     error(JSMSG_GARBAGE_AFTER_INPUT, "function body", TokenKindToDesc(tt));
     return null();
   }
 
   ParseNode* node = funNode;
   // Don't constant-fold inside "use asm" code, as this could create a parse
   // tree that doesn't type-check as asm.js.
   if (!pc_->useAsmOrInsideUseAsm()) {
-    if (!FoldConstants(cx_, &node, &handler)) {
+    if (!FoldConstants(cx_, &node, &handler_)) {
       return null();
     }
   }
   funNode = &node->as<FunctionNode>();
 
   if (!this->setSourceMapInfo()) {
     return null();
   }
@@ -1879,17 +1879,17 @@ bool PerHandlerParser<ParseHandler>::dec
   ParseContext::Scope& varScope = pc_->varScope();
 
   bool hasExtraBodyVarScope = &funScope != &varScope;
 
   // Time to implement the odd semantics of 'arguments'.
   HandlePropertyName argumentsName = cx_->names().arguments;
 
   bool tryDeclareArguments;
-  if (handler.canSkipLazyClosedOverBindings()) {
+  if (handler_.canSkipLazyClosedOverBindings()) {
     tryDeclareArguments =
         funbox->function()->lazyScript()->shouldDeclareArguments();
   } else {
     tryDeclareArguments = hasUsedFunctionSpecialName(argumentsName);
   }
 
   // ES 9.2.12 steps 19 and 20 say formal parameters, lexical bindings,
   // and body-level functions named 'arguments' shadow the arguments
@@ -1984,34 +1984,34 @@ GeneralParser<ParseHandler, Unit>::funct
     }
   } else {
     MOZ_ASSERT(type == ExpressionBody);
 
     // Async functions are implemented as generators, and generators are
     // assumed to be statement lists, to prepend initial `yield`.
     ListNodeType stmtList = null();
     if (pc_->isAsync()) {
-      stmtList = handler.newStatementList(pos());
+      stmtList = handler_.newStatementList(pos());
       if (!stmtList) {
         return null();
       }
     }
 
     Node kid = assignExpr(inHandling, yieldHandling, TripledotProhibited);
     if (!kid) {
       return null();
     }
 
-    body = handler.newExpressionBody(kid);
+    body = handler_.newExpressionBody(kid);
     if (!body) {
       return null();
     }
 
     if (pc_->isAsync()) {
-      handler.addStatementToList(stmtList, body);
+      handler_.addStatementToList(stmtList, body);
       body = stmtList;
     }
   }
 
   MOZ_ASSERT_IF(!pc_->isGenerator() && !pc_->isAsync(),
                 pc_->lastYieldOffset == startYieldOffset);
   MOZ_ASSERT_IF(pc_->isGenerator(), kind != FunctionSyntaxKind::Arrow);
   MOZ_ASSERT_IF(pc_->isGenerator(), type == StatementListBody);
@@ -2020,17 +2020,17 @@ GeneralParser<ParseHandler, Unit>::funct
     MOZ_ASSERT_IF(!pc_->isAsync(), type == StatementListBody);
     if (!declareDotGeneratorName()) {
       return null();
     }
     NameNodeType generator = newDotGeneratorName();
     if (!generator) {
       return null();
     }
-    if (!handler.prependInitialYield(handler.asList(body), generator)) {
+    if (!handler_.prependInitialYield(handler_.asList(body), generator)) {
       return null();
     }
   }
 
   // Declare the 'arguments' and 'this' bindings if necessary before
   // finishing up the scope so these special bindings get marked as closed
   // over if necessary. Arrow functions don't have these bindings.
   if (kind != FunctionSyntaxKind::Arrow) {
@@ -2292,21 +2292,21 @@ bool GeneralParser<ParseHandler, Unit>::
     // When delazifying, we may not have a current token and pos() is
     // garbage. In that case, substitute the first token's position.
     if (!tokenStream.peekTokenPos(&firstTokenPos, firstTokenModifier)) {
       return false;
     }
   }
 
   ListNodeType argsbody =
-      handler.newList(ParseNodeKind::ParamsBody, firstTokenPos);
+      handler_.newList(ParseNodeKind::ParamsBody, firstTokenPos);
   if (!argsbody) {
     return false;
   }
-  handler.setFunctionFormalParametersAndBody(funNode, argsbody);
+  handler_.setFunctionFormalParametersAndBody(funNode, argsbody);
 
   bool hasArguments = false;
   if (parenFreeArrow) {
     hasArguments = true;
   } else {
     bool matched;
     if (!tokenStream.matchToken(&matched, TokenKind::RightParen,
                                 TokenStream::Operand)) {
@@ -2468,17 +2468,18 @@ bool GeneralParser<ParseHandler, Unit>::
           funbox->length = positionalFormals.length() - 1;
         }
         funbox->hasParameterExprs = true;
 
         Node def_expr = assignExprWithoutYieldOrAwait(yieldHandling);
         if (!def_expr) {
           return false;
         }
-        if (!handler.setLastFunctionFormalParameterDefault(funNode, def_expr)) {
+        if (!handler_.setLastFunctionFormalParameterDefault(funNode,
+                                                            def_expr)) {
           return false;
         }
       }
 
       // Setter syntax uniquely requires exactly one argument.
       if (kind == FunctionSyntaxKind::Setter) {
         break;
       }
@@ -2538,17 +2539,17 @@ template <typename Unit>
 bool Parser<FullParseHandler, Unit>::skipLazyInnerFunction(
     FunctionNode* funNode, uint32_t toStringStart, FunctionSyntaxKind kind,
     bool tryAnnexB) {
   // When a lazily-parsed function is called, we only fully parse (and emit)
   // that function, not any of its nested children. The initial syntax-only
   // parse recorded the free variables of nested functions and their extents,
   // so we can skip over them after accounting for their free variables.
 
-  RootedFunction fun(cx_, handler.nextLazyInnerFunction());
+  RootedFunction fun(cx_, handler_.nextLazyInnerFunction());
   FunctionBox* funbox = newFunctionBox(funNode, fun, toStringStart,
                                        Directives(/* strict = */ false),
                                        fun->generatorKind(), fun->asyncKind());
   if (!funbox) {
     return false;
   }
 
   LazyScript* lazy = fun->lazyScript();
@@ -2588,99 +2589,99 @@ bool GeneralParser<ParseHandler, Unit>::
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::addExprAndGetNextTemplStrToken(
     YieldHandling yieldHandling, ListNodeType nodeList, TokenKind* ttp) {
   Node pn = expr(InAllowed, yieldHandling, TripledotProhibited);
   if (!pn) {
     return false;
   }
-  handler.addList(nodeList, pn);
+  handler_.addList(nodeList, pn);
 
   TokenKind tt;
   if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
     return false;
   }
   if (tt != TokenKind::RightCurly) {
     error(JSMSG_TEMPLSTR_UNTERM_EXPR);
     return false;
   }
 
   return tokenStream.getToken(ttp, TokenStream::TemplateTail);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::taggedTemplate(
     YieldHandling yieldHandling, ListNodeType tagArgsList, TokenKind tt) {
-  CallSiteNodeType callSiteObjNode = handler.newCallSiteObject(pos().begin);
+  CallSiteNodeType callSiteObjNode = handler_.newCallSiteObject(pos().begin);
   if (!callSiteObjNode) {
     return false;
   }
-  handler.addList(tagArgsList, callSiteObjNode);
+  handler_.addList(tagArgsList, callSiteObjNode);
 
   while (true) {
     if (!appendToCallSiteObj(callSiteObjNode)) {
       return false;
     }
     if (tt != TokenKind::TemplateHead) {
       break;
     }
 
     if (!addExprAndGetNextTemplStrToken(yieldHandling, tagArgsList, &tt)) {
       return false;
     }
   }
-  handler.setEndPosition(tagArgsList, callSiteObjNode);
+  handler_.setEndPosition(tagArgsList, callSiteObjNode);
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::templateLiteral(
     YieldHandling yieldHandling) {
   NameNodeType literal = noSubstitutionUntaggedTemplate();
   if (!literal) {
     return null();
   }
 
   ListNodeType nodeList =
-      handler.newList(ParseNodeKind::TemplateStringListExpr, literal);
+      handler_.newList(ParseNodeKind::TemplateStringListExpr, literal);
   if (!nodeList) {
     return null();
   }
 
   TokenKind tt;
   do {
     if (!addExprAndGetNextTemplStrToken(yieldHandling, nodeList, &tt)) {
       return null();
     }
 
     literal = noSubstitutionUntaggedTemplate();
     if (!literal) {
       return null();
     }
 
-    handler.addList(nodeList, literal);
+    handler_.addList(nodeList, literal);
   } while (tt == TokenKind::TemplateHead);
   return nodeList;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::functionDefinition(
     FunctionNodeType funNode, uint32_t toStringStart, InHandling inHandling,
     YieldHandling yieldHandling, HandleAtom funName, FunctionSyntaxKind kind,
     GeneratorKind generatorKind, FunctionAsyncKind asyncKind,
     bool tryAnnexB /* = false */) {
   MOZ_ASSERT_IF(kind == FunctionSyntaxKind::Statement, funName);
 
   // When fully parsing a LazyScript, we do not fully reparse its inner
   // functions, which are also lazy. Instead, their free variables and
   // source extents are recorded and may be skipped.
-  if (handler.canSkipLazyInnerFunctions()) {
+  if (handler_.canSkipLazyInnerFunctions()) {
     if (!skipLazyInnerFunction(funNode, toStringStart, kind, tryAnnexB)) {
       return null();
     }
 
     return funNode;
   }
 
   RootedObject proto(cx_);
@@ -2727,17 +2728,17 @@ GeneralParser<ParseHandler, Unit>::funct
     MOZ_ASSERT_IF(directives.strict(), newDirectives.strict());
     MOZ_ASSERT_IF(directives.asmJS(), newDirectives.asmJS());
     directives = newDirectives;
 
     tokenStream.seek(start);
 
     // functionFormalParametersAndBody may have already set body before
     // failing.
-    handler.setFunctionFormalParametersAndBody(funNode, null());
+    handler_.setFunctionFormalParametersAndBody(funNode, null());
   }
 
   return funNode;
 }
 
 template <typename Unit>
 bool Parser<FullParseHandler, Unit>::trySyntaxParseInnerFunction(
     FunctionNode** funNode, HandleFunction fun, uint32_t toStringStart,
@@ -2932,22 +2933,22 @@ bool GeneralParser<ParseHandler, Unit>::
   if (!cookedNode) {
     return false;
   }
 
   JSAtom* atom = tokenStream.getRawTemplateStringAtom();
   if (!atom) {
     return false;
   }
-  NameNodeType rawNode = handler.newTemplateStringLiteral(atom, pos());
+  NameNodeType rawNode = handler_.newTemplateStringLiteral(atom, pos());
   if (!rawNode) {
     return false;
   }
 
-  handler.addToCallSiteObject(callSiteObj, rawNode, cookedNode);
+  handler_.addToCallSiteObject(callSiteObj, rawNode, cookedNode);
   return true;
 }
 
 template <typename Unit>
 FunctionNode* Parser<FullParseHandler, Unit>::standaloneLazyFunction(
     HandleFunction fun, uint32_t toStringStart, bool strict,
     GeneratorKind generatorKind, FunctionAsyncKind asyncKind) {
   MOZ_ASSERT(checkOptionsCalled_);
@@ -2960,17 +2961,17 @@ FunctionNode* Parser<FullParseHandler, U
   } else if (fun->isGetter()) {
     syntaxKind = FunctionSyntaxKind::Getter;
   } else if (fun->isSetter()) {
     syntaxKind = FunctionSyntaxKind::Setter;
   } else if (fun->isArrow()) {
     syntaxKind = FunctionSyntaxKind::Arrow;
   }
 
-  FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(syntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
   Directives directives(strict);
   FunctionBox* funbox = newFunctionBox(funNode, fun, toStringStart, directives,
                                        generatorKind, asyncKind);
   if (!funbox) {
@@ -3004,17 +3005,17 @@ FunctionNode* Parser<FullParseHandler, U
     MOZ_ASSERT(directives == newDirectives);
     return null();
   }
 
   ParseNode* node = funNode;
   // Don't constant-fold inside "use asm" code, as this could create a parse
   // tree that doesn't type-check as asm.js.
   if (!pc_->useAsmOrInsideUseAsm()) {
-    if (!FoldConstants(cx_, &node, &handler)) {
+    if (!FoldConstants(cx_, &node, &handler_)) {
       return null();
     }
   }
   funNode = &node->as<FunctionNode>();
 
   return funNode;
 }
 
@@ -3134,17 +3135,17 @@ bool GeneralParser<ParseHandler, Unit>::
       // because of different context.
       // It should already be checked before this point.
       nameYieldHandling = YieldIsName;
     }
 
     // We already use the correct await-handling at this point, therefore
     // we don't need call AutoAwaitIsKeyword here.
 
-    uint32_t nameOffset = handler.getFunctionNameOffset(*funNode, anyChars);
+    uint32_t nameOffset = handler_.getFunctionNameOffset(*funNode, anyChars);
     if (!checkBindingIdentifier(propertyName, nameOffset, nameYieldHandling)) {
       return false;
     }
   }
 
   if (bodyType == StatementListBody) {
     // Cannot use mustMatchToken here because of internal compiler error on
     // gcc 6.4.0, with linux 64 SM hazard build.
@@ -3178,19 +3179,19 @@ bool GeneralParser<ParseHandler, Unit>::
   if (IsMethodDefinitionKind(kind) && pc_->superScopeNeedsHomeObject()) {
     funbox->setNeedsHomeObject();
   }
 
   if (!finishFunction(isStandaloneFunction)) {
     return false;
   }
 
-  handler.setEndPosition(body, pos().begin);
-  handler.setEndPosition(*funNode, pos().end);
-  handler.setFunctionBody(*funNode, body);
+  handler_.setEndPosition(body, pos().begin);
+  handler_.setEndPosition(*funNode, pos().end);
+  handler_.setFunctionBody(*funNode, body);
 
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::functionStmt(uint32_t toStringStart,
                                                 YieldHandling yieldHandling,
@@ -3262,17 +3263,17 @@ GeneralParser<ParseHandler, Unit>::funct
                                 : DeclarationKind::BodyLevelFunction;
   }
 
   if (!noteDeclaredName(name, kind, pos())) {
     return null();
   }
 
   FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Statement;
-  FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(syntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
   // Under sloppy mode, try Annex B.3.3 semantics. If making an additional
   // 'var' binding of the same name does not throw an early error, do so.
   // This 'var' binding would be assigned the function object when its
   // declaration is reached, not at the start of the block.
@@ -3317,23 +3318,23 @@ GeneralParser<ParseHandler, Unit>::funct
     if (!name) {
       return null();
     }
   } else {
     anyChars.ungetToken();
   }
 
   FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Expression;
-  FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(syntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
   if (invoked) {
-    funNode = handler.setLikelyIIFE(funNode);
+    funNode = handler_.setLikelyIIFE(funNode);
   }
 
   return functionDefinition(funNode, toStringStart, InAllowed, yieldHandling,
                             name, syntaxKind, generatorKind, asyncKind);
 }
 
 /*
  * Return true if this node, known to be an unparenthesized string literal,
@@ -3433,17 +3434,17 @@ inline bool GeneralParser<ParseHandler, 
  * future (because of the hex escape), the Directive Prologue extends through it
  * to the "use strict" statement, which is indeed a directive.
  */
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::maybeParseDirective(
     ListNodeType list, Node possibleDirective, bool* cont) {
   TokenPos directivePos;
   JSAtom* directive =
-      handler.isStringExprStatement(possibleDirective, &directivePos);
+      handler_.isStringExprStatement(possibleDirective, &directivePos);
 
   *cont = !!directive;
   if (!*cont) {
     return true;
   }
 
   if (IsEscapeFreeStringLiteral(directivePos, directive)) {
     // Mark this statement as being a possibly legitimate part of a
@@ -3451,17 +3452,17 @@ bool GeneralParser<ParseHandler, Unit>::
     // useless code. (We mustn't just omit the statement entirely yet, as it
     // could be producing the value of an eval or JSScript execution.)
     //
     // Note that even if the string isn't one we recognize as a directive,
     // the emitter still shouldn't flag it as useless, as it could become a
     // directive in the future. We don't want to interfere with people
     // taking advantage of directive-prologue-enabled features that appear
     // in other browsers first.
-    handler.setInDirectivePrologue(handler.asUnary(possibleDirective));
+    handler_.setInDirectivePrologue(handler_.asUnary(possibleDirective));
 
     if (directive == cx_->names().useStrict) {
       // Functions with non-simple parameter lists (destructuring,
       // default or rest parameters) must not contain a "use strict"
       // directive.
       if (pc_->isFunctionBox()) {
         FunctionBox* funbox = pc_->functionBox();
         if (!funbox->hasSimpleParameterList()) {
@@ -3500,17 +3501,17 @@ bool GeneralParser<ParseHandler, Unit>::
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::statementList(YieldHandling yieldHandling) {
   if (!CheckRecursionLimit(cx_)) {
     return null();
   }
 
-  ListNodeType stmtList = handler.newStatementList(pos());
+  ListNodeType stmtList = handler_.newStatementList(pos());
   if (!stmtList) {
     return null();
   }
 
   bool canHaveDirectives = pc_->atBodyLevel();
   if (canHaveDirectives) {
     anyChars.clearSawOctalEscape();
   }
@@ -3525,52 +3526,52 @@ GeneralParser<ParseHandler, Unit>::state
       }
       return null();
     }
     if (tt == TokenKind::Eof || tt == TokenKind::RightCurly) {
       TokenPos pos;
       if (!tokenStream.peekTokenPos(&pos, TokenStream::Operand)) {
         return null();
       }
-      handler.setListEndPosition(stmtList, pos);
+      handler_.setListEndPosition(stmtList, pos);
       break;
     }
     if (afterReturn) {
       if (!tokenStream.peekOffset(&statementBegin, TokenStream::Operand)) {
         return null();
       }
     }
     Node next = statementListItem(yieldHandling, canHaveDirectives);
     if (!next) {
       if (anyChars.isEOF()) {
         isUnexpectedEOF_ = true;
       }
       return null();
     }
     if (!warnedAboutStatementsAfterReturn) {
       if (afterReturn) {
-        if (!handler.isStatementPermittedAfterReturnStatement(next)) {
+        if (!handler_.isStatementPermittedAfterReturnStatement(next)) {
           if (!warningAt(statementBegin, JSMSG_STMT_AFTER_RETURN)) {
             return null();
           }
 
           warnedAboutStatementsAfterReturn = true;
         }
-      } else if (handler.isReturnStatement(next)) {
+      } else if (handler_.isReturnStatement(next)) {
         afterReturn = true;
       }
     }
 
     if (canHaveDirectives) {
       if (!maybeParseDirective(stmtList, next, &canHaveDirectives)) {
         return null();
       }
     }
 
-    handler.addStatementToList(stmtList, next);
+    handler_.addStatementToList(stmtList, next);
   }
 
   return stmtList;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::condition(
     InHandling inHandling, YieldHandling yieldHandling) {
@@ -3584,17 +3585,17 @@ typename ParseHandler::Node GeneralParse
   }
 
   if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                       JSMSG_PAREN_AFTER_COND)) {
     return null();
   }
 
   /* Check for (a = b) and warn about possible (a == b) mistype. */
-  if (handler.isUnparenthesizedAssignment(pn)) {
+  if (handler_.isUnparenthesizedAssignment(pn)) {
     if (!extraWarning(JSMSG_EQUAL_AS_ASSIGN)) {
       return null();
     }
   }
   return pn;
 }
 
 template <class ParseHandler, typename Unit>
@@ -3772,17 +3773,17 @@ GeneralParser<ParseHandler, Unit>::bindi
   }
 
   Node rhs = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (!rhs) {
     return null();
   }
 
   BinaryNodeType assign =
-      handler.newAssignment(ParseNodeKind::AssignExpr, lhs, rhs);
+      handler_.newAssignment(ParseNodeKind::AssignExpr, lhs, rhs);
   if (!assign) {
     return null();
   }
 
   return assign;
 }
 
 template <class ParseHandler, typename Unit>
@@ -3828,17 +3829,17 @@ GeneralParser<ParseHandler, Unit>::objec
     DeclarationKind kind, YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftCurly));
 
   if (!CheckRecursionLimit(cx_)) {
     return null();
   }
 
   uint32_t begin = pos().begin;
-  ListNodeType literal = handler.newObjectLiteral(begin);
+  ListNodeType literal = handler_.newObjectLiteral(begin);
   if (!literal) {
     return null();
   }
 
   Maybe<DeclarationKind> declKind = Some(kind);
   RootedAtom propAtom(cx_);
   for (;;) {
     TokenKind tt;
@@ -3864,17 +3865,17 @@ GeneralParser<ParseHandler, Unit>::objec
         return null();
       }
 
       NameNodeType inner = bindingIdentifier(kind, yieldHandling);
       if (!inner) {
         return null();
       }
 
-      if (!handler.addSpreadProperty(literal, begin, inner)) {
+      if (!handler_.addSpreadProperty(literal, begin, inner)) {
         return null();
       }
     } else {
       TokenPos namePos = anyChars.nextToken().pos;
 
       PropertyType propType;
       Node propName = propertyName(yieldHandling, PropertyNameInPattern,
                                    declKind, literal, &propType, &propAtom);
@@ -3902,30 +3903,31 @@ GeneralParser<ParseHandler, Unit>::objec
 
         Node bindingExpr =
             hasInitializer ? bindingInitializer(binding, kind, yieldHandling)
                            : binding;
         if (!bindingExpr) {
           return null();
         }
 
-        if (!handler.addPropertyDefinition(literal, propName, bindingExpr)) {
+        if (!handler_.addPropertyDefinition(literal, propName, bindingExpr)) {
           return null();
         }
       } else if (propType == PropertyType::Shorthand) {
         // Handle e.g., |var {x, y} = o| as destructuring shorthand
         // for |var {x: x, y: y} = o|.
         MOZ_ASSERT(TokenKindIsPossibleIdentifierName(tt));
 
         NameNodeType binding = bindingIdentifier(kind, yieldHandling);
         if (!binding) {
           return null();
         }
 
-        if (!handler.addShorthand(literal, handler.asName(propName), binding)) {
+        if (!handler_.addShorthand(literal, handler_.asName(propName),
+                                   binding)) {
           return null();
         }
       } else if (propType == PropertyType::CoverInitializedName) {
         // Handle e.g., |var {x=1, y=2} = o| as destructuring
         // shorthand with default values.
         MOZ_ASSERT(TokenKindIsPossibleIdentifierName(tt));
 
         NameNodeType binding = bindingIdentifier(kind, yieldHandling);
@@ -3936,17 +3938,17 @@ GeneralParser<ParseHandler, Unit>::objec
         tokenStream.consumeKnownToken(TokenKind::Assign);
 
         BinaryNodeType bindingExpr =
             bindingInitializer(binding, kind, yieldHandling);
         if (!bindingExpr) {
           return null();
         }
 
-        if (!handler.addPropertyDefinition(literal, propName, bindingExpr)) {
+        if (!handler_.addPropertyDefinition(literal, propName, bindingExpr)) {
           return null();
         }
       } else {
         errorAt(namePos.begin, JSMSG_NO_VARIABLE_NAME);
         return null();
       }
     }
 
@@ -3967,32 +3969,32 @@ GeneralParser<ParseHandler, Unit>::objec
   if (!mustMatchToken(TokenKind::RightCurly, TokenStream::Operand,
                       [this, begin](TokenKind actual) {
                         this->reportMissingClosing(JSMSG_CURLY_AFTER_LIST,
                                                    JSMSG_CURLY_OPENED, begin);
                       })) {
     return null();
   }
 
-  handler.setEndPosition(literal, pos().end);
+  handler_.setEndPosition(literal, pos().end);
   return literal;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::arrayBindingPattern(
     DeclarationKind kind, YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftBracket));
 
   if (!CheckRecursionLimit(cx_)) {
     return null();
   }
 
   uint32_t begin = pos().begin;
-  ListNodeType literal = handler.newArrayLiteral(begin);
+  ListNodeType literal = handler_.newArrayLiteral(begin);
   if (!literal) {
     return null();
   }
 
   uint32_t index = 0;
   for (;; index++) {
     if (index >= NativeObject::MAX_DENSE_ELEMENTS_COUNT) {
       error(JSMSG_ARRAY_INIT_TOO_BIG);
@@ -4006,33 +4008,33 @@ GeneralParser<ParseHandler, Unit>::array
 
     if (tt == TokenKind::RightBracket) {
       anyChars.ungetToken();
       anyChars.addModifierException(TokenStream::OperandIsNone);
       break;
     }
 
     if (tt == TokenKind::Comma) {
-      if (!handler.addElision(literal, pos())) {
+      if (!handler_.addElision(literal, pos())) {
         return null();
       }
     } else if (tt == TokenKind::TripleDot) {
       uint32_t begin = pos().begin;
 
       TokenKind tt;
       if (!tokenStream.getToken(&tt)) {
         return null();
       }
 
       Node inner = bindingIdentifierOrPattern(kind, yieldHandling, tt);
       if (!inner) {
         return null();
       }
 
-      if (!handler.addSpreadElement(literal, begin, inner)) {
+      if (!handler_.addSpreadElement(literal, begin, inner)) {
         return null();
       }
     } else {
       Node binding = bindingIdentifierOrPattern(kind, yieldHandling, tt);
       if (!binding) {
         return null();
       }
 
@@ -4044,17 +4046,17 @@ GeneralParser<ParseHandler, Unit>::array
 
       Node element = hasInitializer
                          ? bindingInitializer(binding, kind, yieldHandling)
                          : binding;
       if (!element) {
         return null();
       }
 
-      handler.addArrayElement(literal, element);
+      handler_.addArrayElement(literal, element);
     }
 
     if (tt != TokenKind::Comma) {
       // If we didn't already match TokenKind::Comma in above case.
       bool matched;
       if (!tokenStream.matchToken(&matched, TokenKind::Comma,
                                   TokenStream::Operand)) {
         return null();
@@ -4073,17 +4075,17 @@ GeneralParser<ParseHandler, Unit>::array
   if (!mustMatchToken(TokenKind::RightBracket, TokenStream::Operand,
                       [this, begin](TokenKind actual) {
                         this->reportMissingClosing(JSMSG_BRACKET_AFTER_LIST,
                                                    JSMSG_BRACKET_OPENED, begin);
                       })) {
     return null();
   }
 
-  handler.setEndPosition(literal, pos().end);
+  handler_.setEndPosition(literal, pos().end);
   return literal;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::destructuringDeclaration(
     DeclarationKind kind, YieldHandling yieldHandling, TokenKind tt) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(tt));
@@ -4200,17 +4202,17 @@ GeneralParser<ParseHandler, Unit>::decla
   }
 
   Node init = assignExpr(forHeadKind ? InProhibited : InAllowed, yieldHandling,
                          TripledotProhibited);
   if (!init) {
     return null();
   }
 
-  return handler.newAssignment(ParseNodeKind::AssignExpr, pattern, init);
+  return handler_.newAssignment(ParseNodeKind::AssignExpr, pattern, init);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::initializerInNameDeclaration(
     NameNodeType binding, DeclarationKind declKind, bool initialDeclaration,
     YieldHandling yieldHandling, ParseNodeKind* forHeadKind,
     Node* forInOrOfExpression) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Assign));
@@ -4262,17 +4264,17 @@ bool GeneralParser<ParseHandler, Unit>::
       if (!*forInOrOfExpression) {
         return false;
       }
     } else {
       *forHeadKind = ParseNodeKind::ForHead;
     }
   }
 
-  return handler.finishInitializerAssignment(binding, initializer);
+  return handler_.finishInitializerAssignment(binding, initializer);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::NameNodeType
 GeneralParser<ParseHandler, Unit>::declarationName(DeclarationKind declKind,
                                                    TokenKind tt,
                                                    bool initialDeclaration,
                                                    YieldHandling yieldHandling,
@@ -4375,17 +4377,17 @@ GeneralParser<ParseHandler, Unit>::decla
       break;
     case ParseNodeKind::LetDecl:
       declKind = DeclarationKind::Let;
       break;
     default:
       MOZ_CRASH("Unknown declaration kind");
   }
 
-  ListNodeType decl = handler.newDeclarationList(kind, pos());
+  ListNodeType decl = handler_.newDeclarationList(kind, pos());
   if (!decl) {
     return null();
   }
 
   bool moreDeclarations;
   bool initialDeclaration = true;
   do {
     MOZ_ASSERT_IF(!initialDeclaration && forHeadKind,
@@ -4402,17 +4404,17 @@ GeneralParser<ParseHandler, Unit>::decla
                                  yieldHandling, forHeadKind,
                                  forInOrOfExpression)
             : declarationName(declKind, tt, initialDeclaration, yieldHandling,
                               forHeadKind, forInOrOfExpression);
     if (!binding) {
       return null();
     }
 
-    handler.addList(decl, binding);
+    handler_.addList(decl, binding);
 
     // If we have a for-in/of loop, the above call matches the entirety
     // of the loop head (up to the closing parenthesis).
     if (forHeadKind && *forHeadKind != ParseNodeKind::ForHead) {
       break;
     }
 
     initialDeclaration = false;
@@ -4517,22 +4519,22 @@ bool Parser<FullParseHandler, Unit>::nam
       }
 
       NameNodeType importNameNode = newName(importName, importNamePos);
       if (!importNameNode) {
         return false;
       }
 
       BinaryNodeType importSpec =
-          handler.newImportSpec(importNameNode, bindingName);
+          handler_.newImportSpec(importNameNode, bindingName);
       if (!importSpec) {
         return false;
       }
 
-      handler.addList(importSpecSet, importSpec);
+      handler_.addList(importSpecSet, importSpec);
 
       TokenKind next;
       if (!tokenStream.getToken(&next)) {
         return false;
       }
 
       if (next == TokenKind::RightCurly) {
         break;
@@ -4576,22 +4578,22 @@ bool Parser<FullParseHandler, Unit>::nam
       return false;
     }
 
     // The namespace import name is currently required to live on the
     // environment.
     pc_->varScope().lookupDeclaredName(bindingName)->value()->setClosedOver();
 
     BinaryNodeType importSpec =
-        handler.newImportSpec(importName, bindingNameNode);
+        handler_.newImportSpec(importName, bindingNameNode);
     if (!importSpec) {
       return false;
     }
 
-    handler.addList(importSpecSet, importSpec);
+    handler_.addList(importSpecSet, importSpec);
   }
 
   return true;
 }
 
 template <typename Unit>
 BinaryNode* Parser<FullParseHandler, Unit>::importDeclaration() {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Import));
@@ -4603,17 +4605,17 @@ BinaryNode* Parser<FullParseHandler, Uni
 
   uint32_t begin = pos().begin;
   TokenKind tt;
   if (!tokenStream.getToken(&tt)) {
     return null();
   }
 
   ListNodeType importSpecSet =
-      handler.newList(ParseNodeKind::ImportSpecList, pos());
+      handler_.newList(ParseNodeKind::ImportSpecList, pos());
   if (!importSpecSet) {
     return null();
   }
 
   if (tt == TokenKind::String) {
     // Handle the form |import 'a'| by leaving the list empty. This is
     // equivalent to |import {} from 'a'|.
     importSpecSet->pn_pos.end = importSpecSet->pn_pos.begin;
@@ -4642,22 +4644,22 @@ BinaryNode* Parser<FullParseHandler, Uni
         return null();
       }
 
       if (!noteDeclaredName(bindingAtom, DeclarationKind::Import, pos())) {
         return null();
       }
 
       BinaryNodeType importSpec =
-          handler.newImportSpec(importName, bindingName);
+          handler_.newImportSpec(importName, bindingName);
       if (!importSpec) {
         return null();
       }
 
-      handler.addList(importSpecSet, importSpec);
+      handler_.addList(importSpecSet, importSpec);
 
       if (!tokenStream.peekToken(&tt)) {
         return null();
       }
 
       if (tt == TokenKind::Comma) {
         tokenStream.consumeKnownToken(tt);
         if (!tokenStream.getToken(&tt)) {
@@ -4691,18 +4693,18 @@ BinaryNode* Parser<FullParseHandler, Uni
   if (!moduleSpec) {
     return null();
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  BinaryNode* node = handler.newImportDeclaration(importSpecSet, moduleSpec,
-                                                  TokenPos(begin, pos().end));
+  BinaryNode* node = handler_.newImportDeclaration(importSpecSet, moduleSpec,
+                                                   TokenPos(begin, pos().end));
   if (!node || !pc_->sc()->asModuleContext()->builder.processImport(node)) {
     return null();
   }
 
   return node;
 }
 
 template <typename Unit>
@@ -5024,17 +5026,17 @@ GeneralParser<ParseHandler, Unit>::expor
     return null();
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
   BinaryNodeType node =
-      handler.newExportFromDeclaration(begin, specList, moduleSpec);
+      handler_.newExportFromDeclaration(begin, specList, moduleSpec);
   if (!node) {
     return null();
   }
 
   if (!processExportFrom(node)) {
     return null();
   }
 
@@ -5045,29 +5047,29 @@ template <class ParseHandler, typename U
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::exportBatch(uint32_t begin) {
   if (!abortIfSyntaxParser()) {
     return null();
   }
 
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Mul));
 
-  ListNodeType kid = handler.newList(ParseNodeKind::ExportSpecList, pos());
+  ListNodeType kid = handler_.newList(ParseNodeKind::ExportSpecList, pos());
   if (!kid) {
     return null();
   }
 
   // Handle the form |export *| by adding a special export batch
   // specifier to the list.
-  NullaryNodeType exportSpec = handler.newExportBatchSpec(pos());
+  NullaryNodeType exportSpec = handler_.newExportBatchSpec(pos());
   if (!exportSpec) {
     return null();
   }
 
-  handler.addList(kid, exportSpec);
+  handler_.addList(kid, exportSpec);
 
   if (!mustMatchToken(TokenKind::From, JSMSG_FROM_AFTER_EXPORT_STAR)) {
     return null();
   }
 
   return exportFrom(begin, kid);
 }
 
@@ -5105,17 +5107,17 @@ template <class ParseHandler, typename U
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::exportClause(
     uint32_t begin) {
   if (!abortIfSyntaxParser()) {
     return null();
   }
 
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftCurly));
 
-  ListNodeType kid = handler.newList(ParseNodeKind::ExportSpecList, pos());
+  ListNodeType kid = handler_.newList(ParseNodeKind::ExportSpecList, pos());
   if (!kid) {
     return null();
   }
 
   TokenKind tt;
   while (true) {
     // Handle the forms |export {}| and |export { ..., }| (where ... is non
     // empty), by escaping the loop early if the next token is }.
@@ -5152,22 +5154,22 @@ typename ParseHandler::Node GeneralParse
     if (!exportName) {
       return null();
     }
 
     if (!checkExportedNameForClause(exportName)) {
       return null();
     }
 
-    BinaryNodeType exportSpec = handler.newExportSpec(bindingName, exportName);
+    BinaryNodeType exportSpec = handler_.newExportSpec(bindingName, exportName);
     if (!exportSpec) {
       return null();
     }
 
-    handler.addList(kid, exportSpec);
+    handler_.addList(kid, exportSpec);
 
     TokenKind next;
     if (!tokenStream.getToken(&next)) {
       return null();
     }
 
     if (next == TokenKind::RightCurly) {
       break;
@@ -5206,17 +5208,17 @@ typename ParseHandler::Node GeneralParse
     return null();
   }
 
   if (!checkLocalExportNames(kid)) {
     return null();
   }
 
   UnaryNodeType node =
-      handler.newExportDeclaration(kid, TokenPos(begin, pos().end));
+      handler_.newExportDeclaration(kid, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
 
@@ -5239,17 +5241,17 @@ GeneralParser<ParseHandler, Unit>::expor
   if (!matchOrInsertSemicolon()) {
     return null();
   }
   if (!checkExportedNamesForDeclarationList(kid)) {
     return null();
   }
 
   UnaryNodeType node =
-      handler.newExportDeclaration(kid, TokenPos(begin, pos().end));
+      handler_.newExportDeclaration(kid, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
 
@@ -5267,22 +5269,22 @@ GeneralParser<ParseHandler, Unit>::expor
 
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Function));
 
   Node kid = functionStmt(toStringStart, YieldIsName, NameRequired, asyncKind);
   if (!kid) {
     return null();
   }
 
-  if (!checkExportedNameForFunction(handler.asFunction(kid))) {
+  if (!checkExportedNameForFunction(handler_.asFunction(kid))) {
     return null();
   }
 
   UnaryNodeType node =
-      handler.newExportDeclaration(kid, TokenPos(begin, pos().end));
+      handler_.newExportDeclaration(kid, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
 
@@ -5304,17 +5306,17 @@ GeneralParser<ParseHandler, Unit>::expor
     return null();
   }
 
   if (!checkExportedNameForClass(kid)) {
     return null();
   }
 
   UnaryNodeType node =
-      handler.newExportDeclaration(kid, TokenPos(begin, pos().end));
+      handler_.newExportDeclaration(kid, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
 
@@ -5339,17 +5341,17 @@ GeneralParser<ParseHandler, Unit>::expor
   if (!kid) {
     return null();
   }
   if (!checkExportedNamesForDeclarationList(kid)) {
     return null();
   }
 
   UnaryNodeType node =
-      handler.newExportDeclaration(kid, TokenPos(begin, pos().end));
+      handler_.newExportDeclaration(kid, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
 
@@ -5368,17 +5370,17 @@ GeneralParser<ParseHandler, Unit>::expor
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Function));
 
   Node kid =
       functionStmt(toStringStart, YieldIsName, AllowDefaultName, asyncKind);
   if (!kid) {
     return null();
   }
 
-  BinaryNodeType node = handler.newExportDefaultDeclaration(
+  BinaryNodeType node = handler_.newExportDefaultDeclaration(
       kid, null(), TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
@@ -5397,17 +5399,17 @@ GeneralParser<ParseHandler, Unit>::expor
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Class));
 
   ClassNodeType kid =
       classDefinition(YieldIsName, ClassStatement, AllowDefaultName);
   if (!kid) {
     return null();
   }
 
-  BinaryNodeType node = handler.newExportDefaultDeclaration(
+  BinaryNodeType node = handler_.newExportDefaultDeclaration(
       kid, null(), TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
@@ -5435,17 +5437,17 @@ GeneralParser<ParseHandler, Unit>::expor
   if (!kid) {
     return null();
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  BinaryNodeType node = handler.newExportDefaultDeclaration(
+  BinaryNodeType node = handler_.newExportDefaultDeclaration(
       kid, nameNode, TokenPos(begin, pos().end));
   if (!node) {
     return null();
   }
 
   if (!processExport(node)) {
     return null();
   }
@@ -5577,17 +5579,17 @@ GeneralParser<ParseHandler, Unit>::expre
   Node pnexpr = expr(InAllowed, yieldHandling, TripledotProhibited,
                      /* possibleError = */ nullptr, invoked);
   if (!pnexpr) {
     return null();
   }
   if (!matchOrInsertSemicolon()) {
     return null();
   }
-  return handler.newExprStatement(pnexpr, pos().end);
+  return handler_.newExprStatement(pnexpr, pos().end);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::consequentOrAlternative(
     YieldHandling yieldHandling) {
   TokenKind next;
   if (!tokenStream.peekToken(&next, TokenStream::Operand)) {
@@ -5627,22 +5629,22 @@ GeneralParser<ParseHandler, Unit>::conse
     }
 
     TokenPos funcPos = pos();
     Node fun = functionStmt(pos().begin, yieldHandling, NameRequired);
     if (!fun) {
       return null();
     }
 
-    ListNodeType block = handler.newStatementList(funcPos);
+    ListNodeType block = handler_.newStatementList(funcPos);
     if (!block) {
       return null();
     }
 
-    handler.addStatementToList(block, fun);
+    handler_.addStatementToList(block, fun);
     return finishLexicalScope(scope, block);
   }
 
   return statement(yieldHandling);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::TernaryNodeType
@@ -5702,18 +5704,18 @@ GeneralParser<ParseHandler, Unit>::ifSta
     } else {
       elseBranch = null();
     }
     break;
   }
 
   TernaryNodeType ifNode;
   for (int i = condList.length() - 1; i >= 0; i--) {
-    ifNode = handler.newIfStatement(posList[i], condList[i], thenList[i],
-                                    elseBranch);
+    ifNode = handler_.newIfStatement(posList[i], condList[i], thenList[i],
+                                     elseBranch);
     if (!ifNode) {
       return null();
     }
     elseBranch = ifNode;
   }
 
   return ifNode;
 }
@@ -5743,33 +5745,33 @@ GeneralParser<ParseHandler, Unit>::doWhi
   // ES3 and ES5 disagreed, but ES6 conforms to Web reality:
   //   https://bugs.ecmascript.org/show_bug.cgi?id=157
   // To parse |do {} while (true) false| correctly, use Operand.
   bool ignored;
   if (!tokenStream.matchToken(&ignored, TokenKind::Semi,
                               TokenStream::Operand)) {
     return null();
   }
-  return handler.newDoWhileStatement(body, cond, TokenPos(begin, pos().end));
+  return handler_.newDoWhileStatement(body, cond, TokenPos(begin, pos().end));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::whileStatement(YieldHandling yieldHandling) {
   uint32_t begin = pos().begin;
   ParseContext::Statement stmt(pc_, StatementKind::WhileLoop);
   Node cond = condition(InAllowed, yieldHandling);
   if (!cond) {
     return null();
   }
   Node body = statement(yieldHandling);
   if (!body) {
     return null();
   }
-  return handler.newWhileStatement(begin, cond, body);
+  return handler_.newWhileStatement(begin, cond, body);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::matchInOrOf(bool* isForInp,
                                                     bool* isForOfp) {
   TokenKind tt;
   if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
     return false;
@@ -5911,32 +5913,32 @@ bool GeneralParser<ParseHandler, Unit>::
   if (isForOf && letIsIdentifier) {
     errorAt(exprOffset, JSMSG_LET_STARTING_FOROF_LHS);
     return false;
   }
 
   *forHeadKind = isForIn ? ParseNodeKind::ForIn : ParseNodeKind::ForOf;
 
   // Verify the left-hand side expression doesn't have a forbidden form.
-  if (handler.isUnparenthesizedDestructuringPattern(*forInitialPart)) {
+  if (handler_.isUnparenthesizedDestructuringPattern(*forInitialPart)) {
     if (!possibleError.checkForDestructuringErrorOrWarning()) {
       return false;
     }
-  } else if (handler.isName(*forInitialPart)) {
+  } else if (handler_.isName(*forInitialPart)) {
     if (const char* chars = nameIsArgumentsOrEval(*forInitialPart)) {
       // |chars| is "arguments" or "eval" here.
       if (!strictModeErrorAt(exprOffset, JSMSG_BAD_STRICT_ASSIGN, chars)) {
         return false;
       }
     }
 
-    handler.adjustGetToSet(*forInitialPart);
-  } else if (handler.isPropertyAccess(*forInitialPart)) {
+    handler_.adjustGetToSet(*forInitialPart);
+  } else if (handler_.isPropertyAccess(*forInitialPart)) {
     // Permitted: no additional testing/fixup needed.
-  } else if (handler.isFunctionCall(*forInitialPart)) {
+  } else if (handler_.isFunctionCall(*forInitialPart)) {
     if (!strictModeErrorAt(exprOffset, JSMSG_BAD_FOR_LEFTSIDE)) {
       return false;
     }
   } else {
     errorAt(exprOffset, JSMSG_BAD_FOR_LEFTSIDE);
     return false;
   }
 
@@ -6078,17 +6080,17 @@ typename ParseHandler::Node GeneralParse
     }
 
     if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                         JSMSG_PAREN_AFTER_FOR_CTRL)) {
       return null();
     }
 
     TokenPos headPos(begin, pos().end);
-    forHead = handler.newForHead(init, test, update, headPos);
+    forHead = handler_.newForHead(init, test, update, headPos);
     if (!forHead) {
       return null();
     }
   } else {
     MOZ_ASSERT(headKind == ParseNodeKind::ForIn ||
                headKind == ParseNodeKind::ForOf);
 
     // |target| is the LeftHandSideExpression or declaration to which the
@@ -6107,28 +6109,29 @@ typename ParseHandler::Node GeneralParse
     // token follows an {Assignment,}Expression and so must be interpreted
     // as an operand to be consistent with normal expression tokenizing.
     if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                         JSMSG_PAREN_AFTER_FOR_CTRL)) {
       return null();
     }
 
     TokenPos headPos(begin, pos().end);
-    forHead = handler.newForInOrOfHead(headKind, target, iteratedExpr, headPos);
+    forHead =
+        handler_.newForInOrOfHead(headKind, target, iteratedExpr, headPos);
     if (!forHead) {
       return null();
     }
   }
 
   Node body = statement(yieldHandling);
   if (!body) {
     return null();
   }
 
-  ForNodeType forLoop = handler.newForStatement(begin, forHead, body, iflags);
+  ForNodeType forLoop = handler_.newForStatement(begin, forHead, body, iflags);
   if (!forLoop) {
     return null();
   }
 
   if (forLoopLexicalScope) {
     return finishLexicalScope(*forLoopLexicalScope, forLoop);
   }
 
@@ -6161,17 +6164,17 @@ GeneralParser<ParseHandler, Unit>::switc
   }
 
   ParseContext::Statement stmt(pc_, StatementKind::Switch);
   ParseContext::Scope scope(this);
   if (!scope.init(pc_)) {
     return null();
   }
 
-  ListNodeType caseList = handler.newStatementList(pos());
+  ListNodeType caseList = handler_.newStatementList(pos());
   if (!caseList) {
     return null();
   }
 
   bool seenDefault = false;
   TokenKind tt;
   while (true) {
     if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
@@ -6205,17 +6208,17 @@ GeneralParser<ParseHandler, Unit>::switc
         return null();
     }
 
     if (!mustMatchToken(TokenKind::Colon, TokenStream::Operand,
                         JSMSG_COLON_AFTER_CASE)) {
       return null();
     }
 
-    ListNodeType body = handler.newStatementList(pos());
+    ListNodeType body = handler_.newStatementList(pos());
     if (!body) {
       return null();
     }
 
     bool afterReturn = false;
     bool warnedAboutStatementsAfterReturn = false;
     uint32_t statementBegin = 0;
     while (true) {
@@ -6232,47 +6235,47 @@ GeneralParser<ParseHandler, Unit>::switc
         }
       }
       Node stmt = statementListItem(yieldHandling);
       if (!stmt) {
         return null();
       }
       if (!warnedAboutStatementsAfterReturn) {
         if (afterReturn) {
-          if (!handler.isStatementPermittedAfterReturnStatement(stmt)) {
+          if (!handler_.isStatementPermittedAfterReturnStatement(stmt)) {
             if (!warningAt(statementBegin, JSMSG_STMT_AFTER_RETURN)) {
               return null();
             }
 
             warnedAboutStatementsAfterReturn = true;
           }
-        } else if (handler.isReturnStatement(stmt)) {
+        } else if (handler_.isReturnStatement(stmt)) {
           afterReturn = true;
         }
       }
-      handler.addStatementToList(body, stmt);
+      handler_.addStatementToList(body, stmt);
     }
 
     CaseClauseType caseClause =
-        handler.newCaseOrDefault(caseBegin, caseExpr, body);
+        handler_.newCaseOrDefault(caseBegin, caseExpr, body);
     if (!caseClause) {
       return null();
     }
-    handler.addCaseStatementToList(caseList, caseClause);
+    handler_.addCaseStatementToList(caseList, caseClause);
   }
 
   LexicalScopeNodeType lexicalForCaseList = finishLexicalScope(scope, caseList);
   if (!lexicalForCaseList) {
     return null();
   }
 
-  handler.setEndPosition(lexicalForCaseList, pos().end);
-
-  return handler.newSwitchStatement(begin, discriminant, lexicalForCaseList,
-                                    seenDefault);
+  handler_.setEndPosition(lexicalForCaseList, pos().end);
+
+  return handler_.newSwitchStatement(begin, discriminant, lexicalForCaseList,
+                                     seenDefault);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ContinueStatementType
 GeneralParser<ParseHandler, Unit>::continueStatement(
     YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Continue));
   uint32_t begin = pos().begin;
@@ -6294,17 +6297,17 @@ GeneralParser<ParseHandler, Unit>::conti
     }
     return null();
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  return handler.newContinueStatement(label, TokenPos(begin, pos().end));
+  return handler_.newContinueStatement(label, TokenPos(begin, pos().end));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BreakStatementType
 GeneralParser<ParseHandler, Unit>::breakStatement(YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Break));
   uint32_t begin = pos().begin;
 
@@ -6336,17 +6339,17 @@ GeneralParser<ParseHandler, Unit>::break
       return null();
     }
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  return handler.newBreakStatement(label, TokenPos(begin, pos().end));
+  return handler_.newBreakStatement(label, TokenPos(begin, pos().end));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::UnaryNodeType
 GeneralParser<ParseHandler, Unit>::returnStatement(
     YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Return));
   uint32_t begin = pos().begin;
@@ -6376,17 +6379,17 @@ GeneralParser<ParseHandler, Unit>::retur
       }
     }
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  return handler.newReturnStatement(exprNode, TokenPos(begin, pos().end));
+  return handler_.newReturnStatement(exprNode, TokenPos(begin, pos().end));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::UnaryNodeType
 GeneralParser<ParseHandler, Unit>::yieldExpression(InHandling inHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Yield));
   uint32_t begin = pos().begin;
 
@@ -6427,19 +6430,19 @@ GeneralParser<ParseHandler, Unit>::yield
       MOZ_FALLTHROUGH;
     default:
       exprNode = assignExpr(inHandling, YieldIsKeyword, TripledotProhibited);
       if (!exprNode) {
         return null();
       }
   }
   if (kind == ParseNodeKind::YieldStarExpr) {
-    return handler.newYieldStarExpression(begin, exprNode);
-  }
-  return handler.newYieldExpression(begin, exprNode);
+    return handler_.newYieldStarExpression(begin, exprNode);
+  }
+  return handler_.newYieldExpression(begin, exprNode);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::withStatement(YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::With));
   uint32_t begin = pos().begin;
 
@@ -6474,17 +6477,17 @@ GeneralParser<ParseHandler, Unit>::withS
     innerBlock = statement(yieldHandling);
     if (!innerBlock) {
       return null();
     }
   }
 
   pc_->sc()->setBindingsAccessedDynamically();
 
-  return handler.newWithStatement(begin, objectExpr, innerBlock);
+  return handler_.newWithStatement(begin, objectExpr, innerBlock);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::labeledItem(
     YieldHandling yieldHandling) {
   TokenKind tt;
   if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
     return null();
@@ -6543,17 +6546,17 @@ GeneralParser<ParseHandler, Unit>::label
 
   /* Push a label struct and parse the statement. */
   ParseContext::LabelStatement stmt(pc_, label);
   Node pn = labeledItem(yieldHandling);
   if (!pn) {
     return null();
   }
 
-  return handler.newLabeledStatement(label, pn, begin);
+  return handler_.newLabeledStatement(label, pn, begin);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::UnaryNodeType
 GeneralParser<ParseHandler, Unit>::throwStatement(YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Throw));
   uint32_t begin = pos().begin;
 
@@ -6576,17 +6579,17 @@ GeneralParser<ParseHandler, Unit>::throw
   if (!throwExpr) {
     return null();
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
-  return handler.newThrowStatement(throwExpr, TokenPos(begin, pos().end));
+  return handler_.newThrowStatement(throwExpr, TokenPos(begin, pos().end));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::TernaryNodeType
 GeneralParser<ParseHandler, Unit>::tryStatement(YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Try));
   uint32_t begin = pos().begin;
 
@@ -6720,20 +6723,20 @@ GeneralParser<ParseHandler, Unit>::trySt
       return null();
     }
 
     catchScope = finishLexicalScope(scope, catchBody);
     if (!catchScope) {
       return null();
     }
 
-    if (!handler.setupCatchScope(catchScope, catchName, catchBody)) {
-      return null();
-    }
-    handler.setEndPosition(catchScope, pos().end);
+    if (!handler_.setupCatchScope(catchScope, catchName, catchBody)) {
+      return null();
+    }
+    handler_.setEndPosition(catchScope, pos().end);
 
     if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
       return null();
     }
   }
 
   Node finallyBlock = null();
 
@@ -6771,17 +6774,17 @@ GeneralParser<ParseHandler, Unit>::trySt
   } else {
     anyChars.ungetToken();
   }
   if (!catchScope && !finallyBlock) {
     error(JSMSG_CATCH_OR_FINALLY);
     return null();
   }
 
-  return handler.newTryStatement(begin, innerBlock, catchScope, finallyBlock);
+  return handler_.newTryStatement(begin, innerBlock, catchScope, finallyBlock);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::LexicalScopeNodeType
 GeneralParser<ParseHandler, Unit>::catchBlockStatement(
     YieldHandling yieldHandling, ParseContext::Scope& catchParamScope) {
   uint32_t openedPos = pos().begin;
 
@@ -6830,17 +6833,17 @@ GeneralParser<ParseHandler, Unit>::debug
   if (!matchOrInsertSemicolon()) {
     return null();
   }
   p.end = pos().end;
 
   pc_->sc()->setBindingsAccessedDynamically();
   pc_->sc()->setHasDebuggerStatement();
 
-  return handler.newDebuggerStatement(p);
+  return handler_.newDebuggerStatement(p);
 }
 
 static AccessorType ToAccessorType(PropertyType propType) {
   switch (propType) {
     case PropertyType::Getter:
       return AccessorType::Getter;
     case PropertyType::Setter:
       return AccessorType::Setter;
@@ -6929,17 +6932,17 @@ GeneralParser<ParseHandler, Unit>::class
       return null();
     }
   }
 
   if (!mustMatchToken(TokenKind::LeftCurly, JSMSG_CURLY_BEFORE_CLASS)) {
     return null();
   }
 
-  ListNodeType classMembers = handler.newClassMemberList(pos().begin);
+  ListNodeType classMembers = handler_.newClassMemberList(pos().begin);
   if (!classMembers) {
     return null();
   }
 
   Maybe<DeclarationKind> declKind = Nothing();
   size_t numFieldsWithInitializers = 0;
   for (;;) {
     TokenKind tt;
@@ -7009,18 +7012,18 @@ GeneralParser<ParseHandler, Unit>::class
       }
 
       // TODO(khyperia): Implement ASI
       if (tt != TokenKind::Semi) {
         error(JSMSG_MISSING_SEMI_FIELD);
         return null();
       }
 
-      if (!handler.addClassFieldDefinition(classMembers, propName,
-                                           initializer)) {
+      if (!handler_.addClassFieldDefinition(classMembers, propName,
+                                            initializer)) {
         return null();
       }
 
       // TODO(khyperia): Change the below to `continue;` once fields are
       // fully supported in the backend. We can't fail in BytecodeCompiler
       // because of lazy parsing.
       errorAt(propNameOffset, JSMSG_FIELDS_NOT_SUPPORTED);
       return null();
@@ -7078,18 +7081,18 @@ GeneralParser<ParseHandler, Unit>::class
     // parsing and will be amended when class parsing finishes below.
     FunctionNodeType funNode = methodDefinition(
         isConstructor ? classStartOffset : propNameOffset, propType, funName);
     if (!funNode) {
       return null();
     }
 
     AccessorType atype = ToAccessorType(propType);
-    if (!handler.addClassMethodDefinition(classMembers, propName, funNode,
-                                          atype, isStatic)) {
+    if (!handler_.addClassMethodDefinition(classMembers, propName, funNode,
+                                           atype, isStatic)) {
       return null();
     }
   }
 
   // Fields cannot re-use the constructor obtained via JSOP_CLASSCONSTRUCTOR or
   // JSOP_DERIVEDCONSTRUCTOR due to needing to emit calls to the field
   // initializers in the constructor. So, synthesize a new one.
   if (classStmt.constructorBox == nullptr && numFieldsWithInitializers > 0) {
@@ -7099,25 +7102,25 @@ GeneralParser<ParseHandler, Unit>::class
     if (!synthesizedCtor) {
       return null();
     }
 
     MOZ_ASSERT(classStmt.constructorBox != nullptr);
 
     // Note: the *function* has the name of the class, but the *property*
     // containing the function has the name "constructor"
-    Node constructorNameNode = handler.newObjectLiteralPropertyName(
-        cx_->names().constructor, pos());
+    Node constructorNameNode =
+        handler_.newObjectLiteralPropertyName(cx_->names().constructor, pos());
     if (!constructorNameNode) {
       return null();
     }
 
-    if (!handler.addClassMethodDefinition(classMembers, constructorNameNode,
-                                          synthesizedCtor, AccessorType::None,
-                                          /* isStatic = */ false)) {
+    if (!handler_.addClassMethodDefinition(classMembers, constructorNameNode,
+                                           synthesizedCtor, AccessorType::None,
+                                           /* isStatic = */ false)) {
       return null();
     }
   }
 
   uint32_t classEndOffset = pos().end;
   if (FunctionBox* ctorbox = classStmt.constructorBox) {
     // Amend the toStringEnd offset for the constructor now that we've
     // finished parsing the class.
@@ -7176,84 +7179,84 @@ GeneralParser<ParseHandler, Unit>::class
       }
 
       outerName = newName(className, namePos);
       if (!outerName) {
         return null();
       }
     }
 
-    nameNode = handler.newClassNames(outerName, innerName, namePos);
+    nameNode = handler_.newClassNames(outerName, innerName, namePos);
     if (!nameNode) {
       return null();
     }
   }
 
   MOZ_ALWAYS_TRUE(setLocalStrictMode(savedStrictness));
 
-  return handler.newClass(nameNode, classHeritage, membersOrBlock,
-                          TokenPos(classStartOffset, classEndOffset));
+  return handler_.newClass(nameNode, classHeritage, membersOrBlock,
+                           TokenPos(classStartOffset, classEndOffset));
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::synthesizeConstructor(
     HandleAtom className, uint32_t classNameOffset) {
   FunctionSyntaxKind functionSyntaxKind = FunctionSyntaxKind::ClassConstructor;
 
   // Create the function object
   RootedFunction fun(cx_, newFunction(className, functionSyntaxKind,
-                                          GeneratorKind::NotGenerator,
-                                          FunctionAsyncKind::SyncFunction));
+                                      GeneratorKind::NotGenerator,
+                                      FunctionAsyncKind::SyncFunction));
   if (!fun) {
     return null();
   }
 
   // Create the top-level field initializer node
-  FunctionNodeType funNode = handler.newFunction(functionSyntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(functionSyntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
   // Create the FunctionBox and link it to the function object.
   Directives directives(true);
   FunctionBox* funbox = newFunctionBox(funNode, fun, classNameOffset,
                                        directives, GeneratorKind::NotGenerator,
                                        FunctionAsyncKind::SyncFunction);
   if (!funbox) {
     return null();
   }
   funbox->initWithEnclosingParseContext(pc_, functionSyntaxKind);
-  handler.setFunctionBox(funNode, funbox);
+  handler_.setFunctionBox(funNode, funbox);
   funbox->setEnd(anyChars);
 
   // push a SourceParseContext on to the stack.
   SourceParseContext funpc(this, funbox, /* newDirectives = */ nullptr);
   if (!funpc.init()) {
     return null();
   }
 
   TokenPos synthesizedBodyPos = TokenPos(classNameOffset, classNameOffset + 1);
   // Create a ListNode for the parameters + body (there are no parameters)
   ListNodeType argsbody =
-      handler.newList(ParseNodeKind::ParamsBody, synthesizedBodyPos);
+      handler_.newList(ParseNodeKind::ParamsBody, synthesizedBodyPos);
   if (!argsbody) {
     return null();
   }
-  handler.setFunctionFormalParametersAndBody(funNode, argsbody);
+  handler_.setFunctionFormalParametersAndBody(funNode, argsbody);
   funbox->function()->setArgCount(0);
   tokenStream.setFunctionStart(funbox);
 
   // push a LexicalScope on to the stack
   ParseContext::Scope lexicalScope(this);
   if (!lexicalScope.init(pc_)) {
     return null();
   }
 
-  auto stmtList = handler.newStatementList(synthesizedBodyPos);
+  auto stmtList = handler_.newStatementList(synthesizedBodyPos);
   if (!stmtList) {
     return null();
   }
 
   if (!noteUsedName(cx_->names().dotThis)) {
     return null();
   }
 
@@ -7261,20 +7264,20 @@ GeneralParser<ParseHandler, Unit>::synth
     return null();
   }
 
   // Set the function's body to the field assignment.
   auto initializerBody = finishLexicalScope(lexicalScope, stmtList);
   if (!initializerBody) {
     return null();
   }
-  handler.setBeginPosition(initializerBody, stmtList);
-  handler.setEndPosition(initializerBody, stmtList);
-
-  handler.setFunctionBody(funNode, initializerBody);
+  handler_.setBeginPosition(initializerBody, stmtList);
+  handler_.setEndPosition(initializerBody, stmtList);
+
+  handler_.setFunctionBody(funNode, initializerBody);
 
   if (!finishFunction()) {
     return null();
   }
 
   // This function is asserted to set classStmt->constructorBox - however, it's
   // not directly set in this function, but rather in
   // initWithEnclosingParseContext.
@@ -7284,41 +7287,40 @@ GeneralParser<ParseHandler, Unit>::synth
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::fieldInitializer(YieldHandling yieldHandling,
                                                     HandleAtom propAtom) {
   TokenPos fieldPos = pos();
 
   // Create the function object
-  RootedFunction fun(cx_,
-                     newFunction(propAtom, FunctionSyntaxKind::Expression,
-                                 GeneratorKind::NotGenerator,
-                                 FunctionAsyncKind::SyncFunction));
+  RootedFunction fun(cx_, newFunction(propAtom, FunctionSyntaxKind::Expression,
+                                      GeneratorKind::NotGenerator,
+                                      FunctionAsyncKind::SyncFunction));
   if (!fun) {
     return null();
   }
 
   // Create the top-level field initializer node
   FunctionNodeType funNode =
-      handler.newFunction(FunctionSyntaxKind::Expression, fieldPos);
+      handler_.newFunction(FunctionSyntaxKind::Expression, fieldPos);
   if (!funNode) {
     return null();
   }
 
   // Create the FunctionBox and link it to the function object.
   Directives directives(true);
   FunctionBox* funbox = newFunctionBox(funNode, fun, fieldPos.begin, directives,
                                        GeneratorKind::NotGenerator,
                                        FunctionAsyncKind::SyncFunction);
   if (!funbox) {
     return null();
   }
   funbox->initWithEnclosingParseContext(pc_, FunctionSyntaxKind::Expression);
-  handler.setFunctionBox(funNode, funbox);
+  handler_.setFunctionBox(funNode, funbox);
 
   // push a SourceParseContext on to the stack.
   SourceParseContext funpc(this, funbox, /* newDirectives = */ nullptr);
   if (!funpc.init()) {
     return null();
   }
 
   // push a VarScope on to the stack
@@ -7329,21 +7331,21 @@ GeneralParser<ParseHandler, Unit>::field
 
   // push a LexicalScope on to the stack
   ParseContext::Scope lexicalScope(this);
   if (!lexicalScope.init(pc_)) {
     return null();
   }
 
   // Create a ListNode for the parameters + body (there are no parameters)
-  ListNodeType argsbody = handler.newList(ParseNodeKind::ParamsBody, fieldPos);
+  ListNodeType argsbody = handler_.newList(ParseNodeKind::ParamsBody, fieldPos);
   if (!argsbody) {
     return null();
   }
-  handler.setFunctionFormalParametersAndBody(funNode, argsbody);
+  handler_.setFunctionFormalParametersAndBody(funNode, argsbody);
   funbox->function()->setArgCount(0);
 
   tokenStream.setFunctionStart(funbox);
 
   // Parse the expression for the field initializer.
   Node initializerExpr =
       assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (!initializerExpr) {
@@ -7354,58 +7356,58 @@ GeneralParser<ParseHandler, Unit>::field
 
   funbox->usesThis = true;
   NameNodeType thisName = newThisName();
   if (!thisName) {
     return null();
   }
 
   // build `this.field` expression
-  ThisLiteralType propAssignThis = handler.newThisLiteral(fieldPos, thisName);
+  ThisLiteralType propAssignThis = handler_.newThisLiteral(fieldPos, thisName);
   if (!propAssignThis) {
     return null();
   }
 
   NameNodeType propAssignName =
-      handler.newPropertyName(propAtom->asPropertyName(), fieldPos);
+      handler_.newPropertyName(propAtom->asPropertyName(), fieldPos);
   if (!propAssignName) {
     return null();
   }
 
   PropertyAccessType propAssignFieldAccess =
-      handler.newPropertyAccess(propAssignThis, propAssignName);
+      handler_.newPropertyAccess(propAssignThis, propAssignName);
   if (!propAssignFieldAccess) {
     return null();
   }
-  handler.setBeginPosition(propAssignFieldAccess, propAssignName);
-  handler.setEndPosition(propAssignFieldAccess, propAssignName);
+  handler_.setBeginPosition(propAssignFieldAccess, propAssignName);
+  handler_.setEndPosition(propAssignFieldAccess, propAssignName);
 
   // Synthesize an assignment expression for the property.
-  AssignmentNodeType initializerAssignment = handler.newAssignment(
+  AssignmentNodeType initializerAssignment = handler_.newAssignment(
       ParseNodeKind::AssignExpr, propAssignFieldAccess, initializerExpr);
   if (!initializerAssignment) {
     return null();
   }
-  handler.setBeginPosition(initializerAssignment, initializerExpr);
-  handler.setEndPosition(initializerAssignment, initializerExpr);
+  handler_.setBeginPosition(initializerAssignment, initializerExpr);
+  handler_.setEndPosition(initializerAssignment, initializerExpr);
 
   if (!declareFunctionThis()) {
     return null();
   }
 
   // Set the function's body to the field assignment.
   LexicalScopeNodeType initializerBody =
       finishLexicalScope(lexicalScope, initializerAssignment);
   if (!initializerBody) {
     return null();
   }
-  handler.setBeginPosition(initializerBody, initializerAssignment);
-  handler.setEndPosition(initializerBody, initializerAssignment);
-
-  handler.setFunctionBody(funNode, initializerBody);
+  handler_.setBeginPosition(initializerBody, initializerAssignment);
+  handler_.setEndPosition(initializerBody, initializerAssignment);
+
+  handler_.setFunctionBody(funNode, initializerBody);
 
   if (!finishFunction()) {
     return null();
   }
 
   return funNode;
 }
 
@@ -7470,17 +7472,17 @@ typename ParseHandler::Node GeneralParse
       return blockStatement(yieldHandling);
 
     // VariableStatement[?Yield]
     case TokenKind::Var:
       return variableStatement(yieldHandling);
 
     // EmptyStatement
     case TokenKind::Semi:
-      return handler.newEmptyStatement(pos());
+      return handler_.newEmptyStatement(pos());
 
       // ExpressionStatement[?Yield].
 
     case TokenKind::Yield: {
       // Don't use a ternary operator here due to obscure linker issues
       // around using static consts in the arms of a ternary.
       Modifier modifier;
       if (yieldExpressionsSupported()) {
@@ -7703,17 +7705,17 @@ GeneralParser<ParseHandler, Unit>::state
       return blockStatement(yieldHandling);
 
     // VariableStatement[?Yield]
     case TokenKind::Var:
       return variableStatement(yieldHandling);
 
     // EmptyStatement
     case TokenKind::Semi:
-      return handler.newEmptyStatement(pos());
+      return handler_.newEmptyStatement(pos());
 
     // ExpressionStatement[?Yield].
     //
     // These should probably be handled by a single ExpressionStatement
     // function in a default, not split up this way.
     case TokenKind::String:
       if (!canHaveDirectives &&
           anyChars.currentToken().atom() == cx_->names().useAsm) {
@@ -7904,17 +7906,17 @@ typename ParseHandler::Node GeneralParse
   if (!tokenStream.matchToken(&matched, TokenKind::Comma,
                               TokenStream::Operand)) {
     return null();
   }
   if (!matched) {
     return pn;
   }
 
-  ListNodeType seq = handler.newCommaExpressionList(pn);
+  ListNodeType seq = handler_.newCommaExpressionList(pn);
   if (!seq) {
     return null();
   }
   while (true) {
     // Trailing comma before the closing parenthesis is valid in an arrow
     // function parameters list: `(a, b, ) => body`. Check if we are
     // directly under CoverParenthesizedExpressionAndArrowParameterList,
     // and the next two tokens are closing parenthesis and arrow. If all
@@ -7958,17 +7960,17 @@ typename ParseHandler::Node GeneralParse
       // Report any pending expression error.
       if (!possibleErrorInner.checkForExpressionError()) {
         return null();
       }
     } else {
       possibleErrorInner.transferErrorsTo(possibleError);
     }
 
-    handler.addList(seq, pn);
+    handler_.addList(seq, pn);
 
     if (!tokenStream.matchToken(&matched, TokenKind::Comma,
                                 TokenStream::Operand)) {
       return null();
     }
     if (!matched) {
       break;
     }
@@ -8058,17 +8060,17 @@ GeneralParser<ParseHandler, Unit>::orExp
                              : TokenKindIsBinaryOp(tok)) {
       // We're definitely not in a destructuring context, so report any
       // pending expression error now.
       if (possibleError && !possibleError->checkForExpressionError()) {
         return null();
       }
       // Report an error for unary expressions on the LHS of **.
       if (tok == TokenKind::Pow &&
-          handler.isUnparenthesizedUnaryExpression(pn)) {
+          handler_.isUnparenthesizedUnaryExpression(pn)) {
         error(JSMSG_BAD_POW_LEFTSIDE);
         return null();
       }
       pnk = BinaryOpTokenKindToParseNodeKind(tok);
     } else {
       tok = TokenKind::Eof;
       pnk = ParseNodeKind::Limit;
     }
@@ -8081,17 +8083,17 @@ GeneralParser<ParseHandler, Unit>::orExp
     // actual lhs of pnk.
     //
     // The >= in this condition works because it is appendOrCreateList's
     // job to decide if the operator in question is left- or
     // right-associative, and build the corresponding tree.
     while (depth > 0 && Precedence(kindStack[depth - 1]) >= Precedence(pnk)) {
       depth--;
       ParseNodeKind combiningPnk = kindStack[depth];
-      pn = handler.appendOrCreateList(combiningPnk, nodeStack[depth], pn, pc_);
+      pn = handler_.appendOrCreateList(combiningPnk, nodeStack[depth], pn, pc_);
       if (!pn) {
         return null();
       }
     }
 
     if (pnk == ParseNodeKind::Limit) {
       break;
     }
@@ -8142,17 +8144,17 @@ GeneralParser<ParseHandler, Unit>::condE
     return null();
   }
 
   Node elseExpr = assignExpr(inHandling, yieldHandling, TripledotProhibited);
   if (!elseExpr) {
     return null();
   }
 
-  return handler.newConditional(condition, thenExpr, elseExpr);
+  return handler_.newConditional(condition, thenExpr, elseExpr);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::assignExpr(
     InHandling inHandling, YieldHandling yieldHandling,
     TripledotHandling tripledotHandling,
     PossibleError* possibleError /* = nullptr */,
     InvokedPrediction invoked /* = PredictUninvoked */) {
@@ -8312,17 +8314,17 @@ typename ParseHandler::Node GeneralParse
           nextSameLine == TokenKind::LeftParen) {
         asyncKind = FunctionAsyncKind::AsyncFunction;
       } else {
         anyChars.ungetToken();
       }
     }
 
     FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Arrow;
-    FunctionNodeType funNode = handler.newFunction(syntaxKind, startPos);
+    FunctionNodeType funNode = handler_.newFunction(syntaxKind, startPos);
     if (!funNode) {
       return null();
     }
 
     return functionDefinition(funNode, toStringStart, inHandling, yieldHandling,
                               nullptr, syntaxKind, GeneratorKind::NotGenerator,
                               asyncKind);
   }
@@ -8381,37 +8383,37 @@ typename ParseHandler::Node GeneralParse
         possibleErrorInner.transferErrorsTo(possibleError);
       }
 
       anyChars.ungetToken();
       return lhs;
   }
 
   // Verify the left-hand side expression doesn't have a forbidden form.
-  if (handler.isUnparenthesizedDestructuringPattern(lhs)) {
+  if (handler_.isUnparenthesizedDestructuringPattern(lhs)) {
     if (kind != ParseNodeKind::AssignExpr) {
       error(JSMSG_BAD_DESTRUCT_ASS);
       return null();
     }
 
     if (!possibleErrorInner.checkForDestructuringErrorOrWarning()) {
       return null();
     }
-  } else if (handler.isName(lhs)) {
+  } else if (handler_.isName(lhs)) {
     if (const char* chars = nameIsArgumentsOrEval(lhs)) {
       // |chars| is "arguments" or "eval" here.
       if (!strictModeErrorAt(exprPos.begin, JSMSG_BAD_STRICT_ASSIGN, chars)) {
         return null();
       }
     }
 
-    handler.adjustGetToSet(lhs);
-  } else if (handler.isPropertyAccess(lhs)) {
+    handler_.adjustGetToSet(lhs);
+  } else if (handler_.isPropertyAccess(lhs)) {
     // Permitted: no additional testing/fixup needed.
-  } else if (handler.isFunctionCall(lhs)) {
+  } else if (handler_.isFunctionCall(lhs)) {
     if (!strictModeErrorAt(exprPos.begin, JSMSG_BAD_LEFTSIDE_OF_ASS)) {
       return null();
     }
 
     if (possibleError) {
       possibleError->setPendingDestructuringErrorAt(exprPos,
                                                     JSMSG_BAD_DESTRUCT_TARGET);
     }
@@ -8424,74 +8426,74 @@ typename ParseHandler::Node GeneralParse
     return null();
   }
 
   Node rhs = assignExpr(inHandling, yieldHandling, TripledotProhibited);
   if (!rhs) {
     return null();
   }
 
-  return handler.newAssignment(kind, lhs, rhs);
+  return handler_.newAssignment(kind, lhs, rhs);
 }
 
 template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::isValidSimpleAssignmentTarget(
     Node node,
     FunctionCallBehavior behavior /* = ForbidAssignmentToFunctionCalls */) {
   // Note that this method implements *only* a boolean test.  Reporting an
   // error for the various syntaxes that fail this, and warning for the
   // various syntaxes that "pass" this but should not, occurs elsewhere.
 
-  if (handler.isName(node)) {
+  if (handler_.isName(node)) {
     if (!pc_->sc()->strict()) {
       return true;
     }
 
     return !nameIsArgumentsOrEval(node);
   }
 
-  if (handler.isPropertyAccess(node)) {
+  if (handler_.isPropertyAccess(node)) {
     return true;
   }
 
   if (behavior == PermitAssignmentToFunctionCalls) {
-    if (handler.isFunctionCall(node)) {
+    if (handler_.isFunctionCall(node)) {
       return true;
     }
   }
 
   return false;
 }
 
 template <class ParseHandler>
 const char* PerHandlerParser<ParseHandler>::nameIsArgumentsOrEval(Node node) {
-  MOZ_ASSERT(handler.isName(node),
+  MOZ_ASSERT(handler_.isName(node),
              "must only call this function on known names");
 
-  if (handler.isEvalName(node, cx_)) {
+  if (handler_.isEvalName(node, cx_)) {
     return js_eval_str;
   }
-  if (handler.isArgumentsName(node, cx_)) {
+  if (handler_.isArgumentsName(node, cx_)) {
     return js_arguments_str;
   }
   return nullptr;
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::checkIncDecOperand(
     Node operand, uint32_t operandOffset) {
-  if (handler.isName(operand)) {
+  if (handler_.isName(operand)) {
     if (const char* chars = nameIsArgumentsOrEval(operand)) {
       if (!strictModeErrorAt(operandOffset, JSMSG_BAD_STRICT_ASSIGN, chars)) {
         return false;
       }
     }
-  } else if (handler.isPropertyAccess(operand)) {
+  } else if (handler_.isPropertyAccess(operand)) {
     // Permitted: no additional testing/fixup needed.
-  } else if (handler.isFunctionCall(operand)) {
+  } else if (handler_.isFunctionCall(operand)) {
     // Assignment to function calls is forbidden in ES6.  We're still
     // somewhat concerned about sites using this in dead code, so forbid it
     // only in strict mode code (or if the werror option has been set), and
     // otherwise warn.
     if (!strictModeErrorAt(operandOffset, JSMSG_BAD_INCOP_OPERAND)) {
       return false;
     }
   } else {
@@ -8509,17 +8511,17 @@ template <class ParseHandler, typename U
 typename ParseHandler::UnaryNodeType
 GeneralParser<ParseHandler, Unit>::unaryOpExpr(YieldHandling yieldHandling,
                                                ParseNodeKind kind,
                                                uint32_t begin) {
   Node kid = unaryExpr(yieldHandling, TripledotProhibited);
   if (!kid) {
     return null();
   }
-  return handler.newUnary(kind, begin, kid);
+  return handler_.newUnary(kind, begin, kid);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::unaryExpr(
     YieldHandling yieldHandling, TripledotHandling tripledotHandling,
     PossibleError* possibleError /* = nullptr */,
     InvokedPrediction invoked /* = PredictUninvoked */) {
   if (!CheckRecursionLimit(cx_)) {
@@ -8555,17 +8557,17 @@ typename ParseHandler::Node GeneralParse
       //   // Evaluates expression, triggering a runtime ReferenceError for
       //   // the undefined name.
       //   typeof (1, nonExistentName);
       Node kid = unaryExpr(yieldHandling, TripledotProhibited);
       if (!kid) {
         return null();
       }
 
-      return handler.newTypeof(begin, kid);
+      return handler_.newTypeof(begin, kid);
     }
 
     case TokenKind::Inc:
     case TokenKind::Dec: {
       TokenKind tt2;
       if (!tokenStream.getToken(&tt2, TokenStream::Operand)) {
         return null();
       }
@@ -8573,56 +8575,56 @@ typename ParseHandler::Node GeneralParse
       uint32_t operandOffset = pos().begin;
       Node operand = memberExpr(yieldHandling, TripledotProhibited, tt2);
       if (!operand || !checkIncDecOperand(operand, operandOffset)) {
         return null();
       }
       ParseNodeKind pnk = (tt == TokenKind::Inc)
                               ? ParseNodeKind::PreIncrementExpr
                               : ParseNodeKind::PreDecrementExpr;
-      return handler.newUpdate(pnk, begin, operand);
+      return handler_.newUpdate(pnk, begin, operand);
     }
 
     case TokenKind::Delete: {
       uint32_t exprOffset;
       if (!tokenStream.peekOffset(&exprOffset, TokenStream::Operand)) {
         return null();
       }
 
       Node expr = unaryExpr(yieldHandling, TripledotProhibited);
       if (!expr) {
         return null();
       }
 
       // Per spec, deleting any unary expression is valid -- it simply
       // returns true -- except for one case that is illegal in strict mode.
-      if (handler.isName(expr)) {
+      if (handler_.isName(expr)) {
         if (!strictModeErrorAt(exprOffset, JSMSG_DEPRECATED_DELETE_OPERAND)) {
           return null();
         }
 
         pc_->sc()->setBindingsAccessedDynamically();
       }
 
-      return handler.newDelete(begin, expr);
+      return handler_.newDelete(begin, expr);
     }
 
     case TokenKind::Await: {
       if (pc_->isAsync()) {
         if (inParametersOfAsyncFunction()) {
           error(JSMSG_AWAIT_IN_PARAMETER);
           return null();
         }
         Node kid =
             unaryExpr(yieldHandling, tripledotHandling, possibleError, invoked);
         if (!kid) {
           return null();
         }
         pc_->lastAwaitOffset = begin;
-        return handler.newAwaitExpression(begin, kid);
+        return handler_.newAwaitExpression(begin, kid);
       }
     }
 
       MOZ_FALLTHROUGH;
 
     default: {
       Node expr =
           memberExpr(yieldHandling, tripledotHandling, tt,
@@ -8643,17 +8645,17 @@ typename ParseHandler::Node GeneralParse
       tokenStream.consumeKnownToken(tt);
       if (!checkIncDecOperand(expr, begin)) {
         return null();
       }
 
       ParseNodeKind pnk = (tt == TokenKind::Inc)
                               ? ParseNodeKind::PostIncrementExpr
                               : ParseNodeKind::PostDecrementExpr;
-      return handler.newUpdate(pnk, begin, expr);
+      return handler_.newUpdate(pnk, begin, expr);
     }
   }
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::assignExprWithoutYieldOrAwait(
     YieldHandling yieldHandling) {
@@ -8673,28 +8675,28 @@ GeneralParser<ParseHandler, Unit>::assig
   return res;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::argumentList(
     YieldHandling yieldHandling, bool* isSpread,
     PossibleError* possibleError /* = nullptr */) {
-  ListNodeType argsList = handler.newArguments(pos());
+  ListNodeType argsList = handler_.newArguments(pos());
   if (!argsList) {
     return null();
   }
 
   bool matched;
   if (!tokenStream.matchToken(&matched, TokenKind::RightParen,
                               TokenStream::Operand)) {
     return null();
   }
   if (matched) {
-    handler.setEndPosition(argsList, pos().end);
+    handler_.setEndPosition(argsList, pos().end);
     return argsList;
   }
 
   while (true) {
     bool spread = false;
     uint32_t begin = 0;
     if (!tokenStream.matchToken(&matched, TokenKind::TripleDot,
                                 TokenStream::Operand)) {
@@ -8707,23 +8709,23 @@ GeneralParser<ParseHandler, Unit>::argum
     }
 
     Node argNode = assignExpr(InAllowed, yieldHandling, TripledotProhibited,
                               possibleError);
     if (!argNode) {
       return null();
     }
     if (spread) {
-      argNode = handler.newSpread(begin, argNode);
+      argNode = handler_.newSpread(begin, argNode);
       if (!argNode) {
         return null();
       }
     }
 
-    handler.addList(argsList, argNode);
+    handler_.addList(argsList, argNode);
 
     bool matched;
     if (!tokenStream.matchToken(&matched, TokenKind::Comma,
                                 TokenStream::Operand)) {
       return null();
     }
     if (!matched) {
       break;
@@ -8738,17 +8740,17 @@ GeneralParser<ParseHandler, Unit>::argum
     }
   }
 
   if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                       JSMSG_PAREN_AFTER_ARGS)) {
     return null();
   }
 
-  handler.setEndPosition(argsList, pos().end);
+  handler_.setEndPosition(argsList, pos().end);
   return argsList;
 }
 
 bool ParserBase::checkAndMarkSuperScope() {
   if (!pc_->sc()->allowSuperProperty()) {
     return false;
   }
 
@@ -8804,55 +8806,55 @@ typename ParseHandler::Node GeneralParse
         return null();
       }
 
       bool isSpread = false;
       Node args;
       if (matched) {
         args = argumentList(yieldHandling, &isSpread);
       } else {
-        args = handler.newArguments(pos());
+        args = handler_.newArguments(pos());
       }
 
       if (!args) {
         return null();
       }
 
-      lhs = handler.newNewExpression(newBegin, ctorExpr, args);
+      lhs = handler_.newNewExpression(newBegin, ctorExpr, args);
       if (!lhs) {
         return null();
       }
 
       if (isSpread) {
-        handler.setOp(lhs, JSOP_SPREADNEW);
+        handler_.setOp(lhs, JSOP_SPREADNEW);
       }
     }
   } else if (tt == TokenKind::Super) {
     NameNodeType thisName = newThisName();
     if (!thisName) {
       return null();
     }
-    lhs = handler.newSuperBase(thisName, pos());
+    lhs = handler_.newSuperBase(thisName, pos());
     if (!lhs) {
       return null();
     }
   } else if (tt == TokenKind::Import) {
     lhs = importExpr(yieldHandling, allowCallSyntax);
     if (!lhs) {
       return null();
     }
   } else {
     lhs = primaryExpr(yieldHandling, tripledotHandling, tt, possibleError,
                       invoked);
     if (!lhs) {
       return null();
     }
   }
 
-  MOZ_ASSERT_IF(handler.isSuperBase(lhs),
+  MOZ_ASSERT_IF(handler_.isSuperBase(lhs),
                 anyChars.isCurrentTokenType(TokenKind::Super));
 
   while (true) {
     if (!tokenStream.getToken(&tt)) {
       return null();
     }
     if (tt == TokenKind::Eof) {
       break;
@@ -8861,27 +8863,27 @@ typename ParseHandler::Node GeneralParse
     Node nextMember;
     if (tt == TokenKind::Dot) {
       if (!tokenStream.getToken(&tt)) {
         return null();
       }
 
       if (TokenKindIsPossibleIdentifierName(tt)) {
         PropertyName* field = anyChars.currentName();
-        if (handler.isSuperBase(lhs) && !checkAndMarkSuperScope()) {
+        if (handler_.isSuperBase(lhs) && !checkAndMarkSuperScope()) {
           error(JSMSG_BAD_SUPERPROP, "property");
           return null();
         }
 
-        NameNodeType name = handler.newPropertyName(field, pos());
+        NameNodeType name = handler_.newPropertyName(field, pos());
         if (!name) {
           return null();
         }
 
-        nextMember = handler.newPropertyAccess(lhs, name);
+        nextMember = handler_.newPropertyAccess(lhs, name);
         if (!nextMember) {
           return null();
         }
       } else {
         error(JSMSG_NAME_AFTER_DOT);
         return null();
       }
     } else if (tt == TokenKind::LeftBracket) {
@@ -8890,28 +8892,28 @@ typename ParseHandler::Node GeneralParse
         return null();
       }
 
       if (!mustMatchToken(TokenKind::RightBracket, TokenStream::Operand,
                           JSMSG_BRACKET_IN_INDEX)) {
         return null();
       }
 
-      if (handler.isSuperBase(lhs) && !checkAndMarkSuperScope()) {
+      if (handler_.isSuperBase(lhs) && !checkAndMarkSuperScope()) {
         error(JSMSG_BAD_SUPERPROP, "member");
         return null();
       }
-      nextMember = handler.newPropertyByValue(lhs, propExpr, pos().end);
+      nextMember = handler_.newPropertyByValue(lhs, propExpr, pos().end);
       if (!nextMember) {
         return null();
       }
     } else if ((allowCallSyntax && tt == TokenKind::LeftParen) ||
                tt == TokenKind::TemplateHead ||
                tt == TokenKind::NoSubsTemplate) {
-      if (handler.isSuperBase(lhs)) {
+      if (handler_.isSuperBase(lhs)) {
         if (!pc_->sc()->allowSuperCall()) {
           error(JSMSG_BAD_SUPERCALL);
           return null();
         }
 
         if (tt != TokenKind::LeftParen) {
           error(JSMSG_BAD_SUPER);
           return null();
@@ -8921,63 +8923,63 @@ typename ParseHandler::Node GeneralParse
         // generator, we still inherit the yieldHandling of the
         // memberExpression, per spec. Curious.
         bool isSpread = false;
         Node args = argumentList(yieldHandling, &isSpread);
         if (!args) {
           return null();
         }
 
-        nextMember = handler.newSuperCall(lhs, args);
+        nextMember = handler_.newSuperCall(lhs, args);
         if (!nextMember) {
           return null();
         }
 
         if (isSpread) {
-          handler.setOp(nextMember, JSOP_SPREADSUPERCALL);
+          handler_.setOp(nextMember, JSOP_SPREADSUPERCALL);
         }
 
         NameNodeType thisName = newThisName();
         if (!thisName) {
           return null();
         }
 
-        nextMember = handler.newSetThis(thisName, nextMember);
+        nextMember = handler_.newSetThis(thisName, nextMember);
         if (!nextMember) {
           return null();
         }
       } else {
-        if (options().selfHostingMode && handler.isPropertyAccess(lhs)) {
+        if (options().selfHostingMode && handler_.isPropertyAccess(lhs)) {
           error(JSMSG_SELFHOSTED_METHOD_CALL);
           return null();
         }
 
         JSOp op = JSOP_CALL;
         bool maybeAsyncArrow = false;
-        if (PropertyName* prop = handler.maybeDottedProperty(lhs)) {
+        if (PropertyName* prop = handler_.maybeDottedProperty(lhs)) {
           // Use the JSOP_FUN{APPLY,CALL} optimizations given the
           // right syntax.
           if (prop == cx_->names().apply) {
             op = JSOP_FUNAPPLY;
             if (pc_->isFunctionBox()) {
               pc_->functionBox()->usesApply = true;
             }
           } else if (prop == cx_->names().call) {
             op = JSOP_FUNCALL;
           }
         } else if (tt == TokenKind::LeftParen) {
-          if (handler.isAsyncKeyword(lhs, cx_)) {
+          if (handler_.isAsyncKeyword(lhs, cx_)) {
             // |async (| can be the start of an async arrow
             // function, so we need to defer reporting possible
             // errors from destructuring syntax. To give better
             // error messages, we only allow the AsyncArrowHead
             // part of the CoverCallExpressionAndAsyncArrowHead
             // syntax when the initial name is "async".
             maybeAsyncArrow = true;
-          } else if (handler.isEvalName(lhs, cx_)) {
+          } else if (handler_.isEvalName(lhs, cx_)) {
             // Select the right EVAL op and flag pc_ as having a
             // direct eval.
             op = pc_->sc()->strict() ? JSOP_STRICTEVAL : JSOP_EVAL;
             pc_->sc()->setBindingsAccessedDynamically();
             pc_->sc()->setHasDirectEval();
 
             // In non-strict mode code, direct calls to eval can
             // add variables to the call object.
@@ -9007,66 +9009,66 @@ typename ParseHandler::Node GeneralParse
               op = JSOP_SPREADEVAL;
             } else if (op == JSOP_STRICTEVAL) {
               op = JSOP_STRICTSPREADEVAL;
             } else {
               op = JSOP_SPREADCALL;
             }
           }
 
-          nextMember = handler.newCall(lhs, args);
+          nextMember = handler_.newCall(lhs, args);
           if (!nextMember) {
             return null();
           }
         } else {
-          ListNodeType args = handler.newArguments(pos());
+          ListNodeType args = handler_.newArguments(pos());
           if (!args) {
             return null();
           }
 
           if (!taggedTemplate(yieldHandling, args, tt)) {
             return null();
           }
 
-          nextMember = handler.newTaggedTemplate(lhs, args);
+          nextMember = handler_.newTaggedTemplate(lhs, args);
           if (!nextMember) {
             return null();
           }
         }
-        handler.setOp(nextMember, op);
+        handler_.setOp(nextMember, op);
       }
     } else {
       anyChars.ungetToken();
-      if (handler.isSuperBase(lhs)) {
+      if (handler_.isSuperBase(lhs)) {
         break;
       }
       return lhs;
     }
 
     lhs = nextMember;
   }
 
-  if (handler.isSuperBase(lhs)) {
+  if (handler_.isSuperBase(lhs)) {
     error(JSMSG_BAD_SUPER);
     return null();
   }
 
   return lhs;
 }
 
 template <class ParseHandler>
 inline typename ParseHandler::NameNodeType
 PerHandlerParser<ParseHandler>::newName(PropertyName* name) {
   return newName(name, pos());
 }
 
 template <class ParseHandler>
 inline typename ParseHandler::NameNodeType
 PerHandlerParser<ParseHandler>::newName(PropertyName* name, TokenPos pos) {
-  return handler.newName(name, pos, cx_);
+  return handler_.newName(name, pos, cx_);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::checkLabelOrIdentifierReference(
     PropertyName* ident, uint32_t offset, YieldHandling yieldHandling,
     TokenKind hint /* = TokenKind::Limit */) {
   TokenKind tt;
   if (hint == TokenKind::Limit) {
@@ -9210,40 +9212,40 @@ PerHandlerParser<ParseHandler>::identifi
   }
 
   return id;
 }
 
 template <class ParseHandler>
 typename ParseHandler::NameNodeType
 PerHandlerParser<ParseHandler>::stringLiteral() {
-  return handler.newStringLiteral(anyChars.currentToken().atom(), pos());
+  return handler_.newStringLiteral(anyChars.currentToken().atom(), pos());
 }
 
 template <class ParseHandler>
 typename ParseHandler::Node
 PerHandlerParser<ParseHandler>::noSubstitutionTaggedTemplate() {
   if (anyChars.hasInvalidTemplateEscape()) {
     anyChars.clearInvalidTemplateEscape();
-    return handler.newRawUndefinedLiteral(pos());
-  }
-
-  return handler.newTemplateStringLiteral(anyChars.currentToken().atom(),
-                                          pos());
+    return handler_.newRawUndefinedLiteral(pos());
+  }
+
+  return handler_.newTemplateStringLiteral(anyChars.currentToken().atom(),
+                                           pos());
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::NameNodeType
 GeneralParser<ParseHandler, Unit>::noSubstitutionUntaggedTemplate() {
   if (!tokenStream.checkForInvalidTemplateEscapeError()) {
     return null();
   }
 
-  return handler.newTemplateStringLiteral(anyChars.currentToken().atom(),
-                                          pos());
+  return handler_.newTemplateStringLiteral(anyChars.currentToken().atom(),
+                                           pos());
 }
 
 template <typename Unit>
 RegExpLiteral* Parser<FullParseHandler, Unit>::newRegExp() {
   MOZ_ASSERT(!options().selfHostingMode);
 
   // Create the regexp and check its syntax.
   const auto& chars = tokenStream.getCharBuffer();
@@ -9251,17 +9253,17 @@ RegExpLiteral* Parser<FullParseHandler, 
 
   Rooted<RegExpObject*> reobj(cx_);
   reobj = RegExpObject::create(cx_, chars.begin(), chars.length(), flags,
                                anyChars, TenuredObject);
   if (!reobj) {
     return null();
   }
 
-  return handler.newRegExp(reobj, pos(), *this);
+  return handler_.newRegExp(reobj, pos(), *this);
 }
 
 template <typename Unit>
 SyntaxParseHandler::RegExpLiteralType
 Parser<SyntaxParseHandler, Unit>::newRegExp() {
   MOZ_ASSERT(!options().selfHostingMode);
 
   // Only check the regexp's syntax, but don't create a regexp object.
@@ -9272,17 +9274,17 @@ Parser<SyntaxParseHandler, Unit>::newReg
   {
     LifoAllocScope scopeAlloc(&alloc_);
     if (!js::irregexp::ParsePatternSyntax(anyChars, scopeAlloc.alloc(), source,
                                           flags & UnicodeFlag)) {
       return null();
     }
   }
 
-  return handler.newRegExp(SyntaxParseHandler::NodeGeneric, pos(), *this);
+  return handler_.newRegExp(SyntaxParseHandler::NodeGeneric, pos(), *this);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::RegExpLiteralType
 GeneralParser<ParseHandler, Unit>::newRegExp() {
   return asFinalParser()->newRegExp();
 }
 
@@ -9298,25 +9300,25 @@ BigIntLiteral* Parser<FullParseHandler, 
   BigInt* b = js::ParseBigIntLiteral(cx_, source);
   if (!b) {
     return null();
   }
 
   // newBigInt immediately puts "b" in a BigIntBox, which is allocated using
   // tempLifoAlloc, avoiding any potential GC.  Therefore it's OK to pass a
   // raw pointer.
-  return handler.newBigInt(b, pos(), *this);
+  return handler_.newBigInt(b, pos(), *this);
 }
 
 template <typename Unit>
 SyntaxParseHandler::BigIntLiteralType
 Parser<SyntaxParseHandler, Unit>::newBigInt() {
   // The tokenizer has already checked the syntax of the bigint.
 
-  return handler.newBigInt();
+  return handler_.newBigInt();
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BigIntLiteralType
 GeneralParser<ParseHandler, Unit>::newBigInt() {
   return asFinalParser()->newBigInt();
 }
 
@@ -9324,88 +9326,88 @@ GeneralParser<ParseHandler, Unit>::newBi
 // |possibleError| is the surrounding PossibleError state.
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::checkDestructuringAssignmentTarget(
     Node expr, TokenPos exprPos, PossibleError* exprPossibleError,
     PossibleError* possibleError, TargetBehavior behavior) {
   // Report any pending expression error if we're definitely not in a
   // destructuring context or the possible destructuring target is a
   // property accessor.
-  if (!possibleError || handler.isPropertyAccess(expr)) {
+  if (!possibleError || handler_.isPropertyAccess(expr)) {
     return exprPossibleError->checkForExpressionError();
   }
 
   // |expr| may end up as a destructuring assignment target, so we need to
   // validate it's either a name or can be parsed as a nested destructuring
   // pattern. Property accessors are also valid assignment targets, but
   // those are already handled above.
 
   exprPossibleError->transferErrorsTo(possibleError);
 
   // Return early if a pending destructuring error is already present.
   if (possibleError->hasPendingDestructuringError()) {
     return true;
   }
 
-  if (handler.isName(expr)) {
-    checkDestructuringAssignmentName(handler.asName(expr), exprPos,
+  if (handler_.isName(expr)) {
+    checkDestructuringAssignmentName(handler_.asName(expr), exprPos,
                                      possibleError);
     return true;
   }
 
-  if (handler.isUnparenthesizedDestructuringPattern(expr)) {
+  if (handler_.isUnparenthesizedDestructuringPattern(expr)) {
     if (behavior == TargetBehavior::ForbidAssignmentPattern) {
       possibleError->setPendingDestructuringErrorAt(exprPos,
                                                     JSMSG_BAD_DESTRUCT_TARGET);
     }
     return true;
   }
 
   // Parentheses are forbidden around destructuring *patterns* (but allowed
   // around names). Use our nicer error message for parenthesized, nested
   // patterns if nested destructuring patterns are allowed.
-  if (handler.isParenthesizedDestructuringPattern(expr) &&
+  if (handler_.isParenthesizedDestructuringPattern(expr) &&
       behavior != TargetBehavior::ForbidAssignmentPattern) {
     possibleError->setPendingDestructuringErrorAt(exprPos,
                                                   JSMSG_BAD_DESTRUCT_PARENS);
   } else {
     possibleError->setPendingDestructuringErrorAt(exprPos,
                                                   JSMSG_BAD_DESTRUCT_TARGET);
   }
 
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 void GeneralParser<ParseHandler, Unit>::checkDestructuringAssignmentName(
     NameNodeType name, TokenPos namePos, PossibleError* possibleError) {
 #ifdef DEBUG
   // GCC 8.0.1 crashes if this is a one-liner.
-  bool isName = handler.isName(name);
+  bool isName = handler_.isName(name);
   MOZ_ASSERT(isName);
 #endif
 
   // Return early if a pending destructuring error is already present.
   if (possibleError->hasPendingDestructuringError()) {
     return;
   }
 
   if (pc_->sc()->needStrictChecks()) {
-    if (handler.isArgumentsName(name, cx_)) {
+    if (handler_.isArgumentsName(name, cx_)) {
       if (pc_->sc()->strict()) {
         possibleError->setPendingDestructuringErrorAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_ARGUMENTS);
       } else {
         possibleError->setPendingDestructuringWarningAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_ARGUMENTS);
       }
       return;
     }
 
-    if (handler.isEvalName(name, cx_)) {
+    if (handler_.isEvalName(name, cx_)) {
       if (pc_->sc()->strict()) {
         possibleError->setPendingDestructuringErrorAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_EVAL);
       } else {
         possibleError->setPendingDestructuringWarningAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_EVAL);
       }
       return;
@@ -9424,17 +9426,17 @@ bool GeneralParser<ParseHandler, Unit>::
   //   DestructuringAssignmentTarget[?Yield, ?Await]
   //   DestructuringAssignmentTarget[?Yield, ?Await] Initializer[+In,
   //                                                             ?Yield,
   //                                                             ?Await]
 
   // If |expr| is an assignment element with an initializer expression, its
   // destructuring assignment target was already validated in assignExpr().
   // Otherwise we need to check that |expr| is a valid destructuring target.
-  if (handler.isUnparenthesizedAssignment(expr)) {
+  if (handler_.isUnparenthesizedAssignment(expr)) {
     // Report any pending expression error if we're definitely not in a
     // destructuring context.
     if (!possibleError) {
       return exprPossibleError->checkForExpressionError();
     }
 
     exprPossibleError->transferErrorsTo(possibleError);
     return true;
@@ -9445,32 +9447,32 @@ bool GeneralParser<ParseHandler, Unit>::
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::arrayInitializer(
     YieldHandling yieldHandling, PossibleError* possibleError) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftBracket));
 
   uint32_t begin = pos().begin;
-  ListNodeType literal = handler.newArrayLiteral(begin);
+  ListNodeType literal = handler_.newArrayLiteral(begin);
   if (!literal) {
     return null();
   }
 
   TokenKind tt;
   if (!tokenStream.getToken(&tt, TokenStream::Operand)) {
     return null();
   }
 
   if (tt == TokenKind::RightBracket) {
     /*
      * Mark empty arrays as non-constant, since we cannot easily
      * determine their type.
      */
-    handler.setListHasNonConstInitializer(literal);
+    handler_.setListHasNonConstInitializer(literal);
   } else {
     anyChars.ungetToken();
 
     for (uint32_t index = 0;; index++) {
       if (index >= NativeObject::MAX_DENSE_ELEMENTS_COUNT) {
         error(JSMSG_ARRAY_INIT_TOO_BIG);
         return null();
       }
@@ -9480,17 +9482,17 @@ GeneralParser<ParseHandler, Unit>::array
         return null();
       }
       if (tt == TokenKind::RightBracket) {
         break;
       }
 
       if (tt == TokenKind::Comma) {
         tokenStream.consumeKnownToken(TokenKind::Comma, TokenStream::Operand);
-        if (!handler.addElision(literal, pos())) {
+        if (!handler_.addElision(literal, pos())) {
           return null();
         }
         continue;
       }
 
       if (tt == TokenKind::TripleDot) {
         tokenStream.consumeKnownToken(TokenKind::TripleDot,
                                       TokenStream::Operand);
@@ -9507,17 +9509,17 @@ GeneralParser<ParseHandler, Unit>::array
         if (!inner) {
           return null();
         }
         if (!checkDestructuringAssignmentTarget(
                 inner, innerPos, &possibleErrorInner, possibleError)) {
           return null();
         }
 
-        if (!handler.addSpreadElement(literal, begin, inner)) {
+        if (!handler_.addSpreadElement(literal, begin, inner)) {
           return null();
         }
       } else {
         TokenPos elementPos;
         if (!tokenStream.peekTokenPos(&elementPos, TokenStream::Operand)) {
           return null();
         }
 
@@ -9526,17 +9528,17 @@ GeneralParser<ParseHandler, Unit>::array
                                   &possibleErrorInner);
         if (!element) {
           return null();
         }
         if (!checkDestructuringAssignmentElement(
                 element, elementPos, &possibleErrorInner, possibleError)) {
           return null();
         }
-        handler.addArrayElement(literal, element);
+        handler_.addArrayElement(literal, element);
       }
 
       bool matched;
       if (!tokenStream.matchToken(&matched, TokenKind::Comma,
                                   TokenStream::Operand)) {
         return null();
       }
       if (!matched) {
@@ -9554,17 +9556,17 @@ GeneralParser<ParseHandler, Unit>::array
                           this->reportMissingClosing(JSMSG_BRACKET_AFTER_LIST,
                                                      JSMSG_BRACKET_OPENED,
                                                      begin);
                         })) {
       return null();
     }
   }
 
-  handler.setEndPosition(literal, pos().end);
+  handler_.setEndPosition(literal, pos().end);
   return literal;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::propertyName(
     YieldHandling yieldHandling, PropertyNameContext propertyNameContext,
     const Maybe<DeclarationKind>& maybeDecl, ListNodeType propList,
     PropertyType* propType, MutableHandleAtom propAtom) {
@@ -9630,17 +9632,17 @@ typename ParseHandler::Node GeneralParse
         return null();
       }
       break;
 
     case TokenKind::String: {
       propAtom.set(anyChars.currentToken().atom());
       uint32_t index;
       if (propAtom->isIndex(&index)) {
-        propName = handler.newNumber(index, NoDecimal, pos());
+        propName = handler_.newNumber(index, NoDecimal, pos());
         if (!propName) {
           return null();
         }
         break;
       }
       propName = stringLiteral();
       if (!propName) {
         return null();
@@ -9661,17 +9663,17 @@ typename ParseHandler::Node GeneralParse
         error(JSMSG_UNEXPECTED_TOKEN, "property name", TokenKindToDesc(ltok));
         return null();
       }
 
       propAtom.set(anyChars.currentName());
       // Do not look for accessor syntax on generator or async methods.
       if (isGenerator || isAsync ||
           !(ltok == TokenKind::Get || ltok == TokenKind::Set)) {
-        propName = handler.newObjectLiteralPropertyName(propAtom, pos());
+        propName = handler_.newObjectLiteralPropertyName(propAtom, pos());
         if (!propName) {
           return null();
         }
         break;
       }
 
       *propType =
           ltok == TokenKind::Get ? PropertyType::Getter : PropertyType::Setter;
@@ -9681,30 +9683,30 @@ typename ParseHandler::Node GeneralParse
       TokenKind tt;
       if (!tokenStream.peekToken(&tt)) {
         return null();
       }
       if (TokenKindIsPossibleIdentifierName(tt)) {
         tokenStream.consumeKnownToken(tt);
 
         propAtom.set(anyChars.currentName());
-        return handler.newObjectLiteralPropertyName(propAtom, pos());
+        return handler_.newObjectLiteralPropertyName(propAtom, pos());
       }
       if (tt == TokenKind::String) {
         tokenStream.consumeKnownToken(TokenKind::String);
 
         propAtom.set(anyChars.currentToken().atom());
 
         uint32_t index;
         if (propAtom->isIndex(&index)) {
           propAtom.set(NumberToAtom(cx_, index));
           if (!propAtom.get()) {
             return null();
           }
-          return handler.newNumber(index, NoDecimal, pos());
+          return handler_.newNumber(index, NoDecimal, pos());
         }
         return stringLiteral();
       }
       if (tt == TokenKind::Number) {
         tokenStream.consumeKnownToken(TokenKind::Number);
 
         propAtom.set(NumberToAtom(cx_, anyChars.currentToken().number()));
         if (!propAtom.get()) {
@@ -9715,17 +9717,17 @@ typename ParseHandler::Node GeneralParse
       if (tt == TokenKind::LeftBracket) {
         tokenStream.consumeKnownToken(TokenKind::LeftBracket);
 
         return computedPropertyName(yieldHandling, maybeDecl,
                                     propertyNameContext, propList);
       }
 
       // Not an accessor property after all.
-      propName = handler.newObjectLiteralPropertyName(propAtom.get(), pos());
+      propName = handler_.newObjectLiteralPropertyName(propAtom.get(), pos());
       if (!propName) {
         return null();
       }
       break;
     }
   }
 
   TokenKind tt;
@@ -9797,40 +9799,40 @@ GeneralParser<ParseHandler, Unit>::compu
   uint32_t begin = pos().begin;
 
   if (maybeDecl) {
     if (*maybeDecl == DeclarationKind::FormalParameter) {
       pc_->functionBox()->hasParameterExprs = true;
     }
   } else if (propertyNameContext ==
              PropertyNameContext::PropertyNameInLiteral) {
-    handler.setListHasNonConstInitializer(literal);
+    handler_.setListHasNonConstInitializer(literal);
   }
 
   Node assignNode = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (!assignNode) {
     return null();
   }
 
   if (!mustMatchToken(TokenKind::RightBracket, TokenStream::Operand,
                       JSMSG_COMP_PROP_UNTERM_EXPR)) {
     return null();
   }
-  return handler.newComputedName(assignNode, begin, pos().end);
+  return handler_.newComputedName(assignNode, begin, pos().end);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
 GeneralParser<ParseHandler, Unit>::objectLiteral(YieldHandling yieldHandling,
                                                  PossibleError* possibleError) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftCurly));
 
   uint32_t openedPos = pos().begin;
 
-  ListNodeType literal = handler.newObjectLiteral(pos().begin);
+  ListNodeType literal = handler_.newObjectLiteral(pos().begin);
   if (!literal) {
     return null();
   }
 
   bool seenPrototypeMutation = false;
   bool seenCoverInitializedName = false;
   Maybe<DeclarationKind> declKind = Nothing();
   RootedAtom propAtom(cx_);
@@ -9859,17 +9861,17 @@ GeneralParser<ParseHandler, Unit>::objec
       if (!inner) {
         return null();
       }
       if (!checkDestructuringAssignmentTarget(
               inner, innerPos, &possibleErrorInner, possibleError,
               TargetBehavior::ForbidAssignmentPattern)) {
         return null();
       }
-      if (!handler.addSpreadProperty(literal, begin, inner)) {
+      if (!handler_.addSpreadProperty(literal, begin, inner)) {
         return null();
       }
     } else {
       TokenPos namePos = anyChars.nextToken().pos;
 
       PropertyType propType;
       Node propName = propertyName(yieldHandling, PropertyNameInLiteral,
                                    declKind, literal, &propType, &propAtom);
@@ -9911,27 +9913,28 @@ GeneralParser<ParseHandler, Unit>::objec
           }
           seenPrototypeMutation = true;
 
           // This occurs *only* if we observe PropertyType::Normal!
           // Only |__proto__: v| mutates [[Prototype]]. Getters,
           // setters, method/generator definitions, computed
           // property name versions of all of these, and shorthands
           // do not.
-          if (!handler.addPrototypeMutation(literal, namePos.begin, propExpr)) {
+          if (!handler_.addPrototypeMutation(literal, namePos.begin,
+                                             propExpr)) {
             return null();
           }
         } else {
           BinaryNodeType propDef =
-              handler.newPropertyDefinition(propName, propExpr);
+              handler_.newPropertyDefinition(propName, propExpr);
           if (!propDef) {
             return null();
           }
 
-          handler.addPropertyDefinition(literal, propDef);
+          handler_.addPropertyDefinition(literal, propDef);
         }
       } else if (propType == PropertyType::Shorthand) {
         /*
          * Support, e.g., |({x, y} = o)| as destructuring shorthand
          * for |({x: x, y: y} = o)|, and |var o = {x, y}| as
          * initializer shorthand for |var o = {x: x, y: y}|.
          */
         Rooted<PropertyName*> name(cx_, identifierReference(yieldHandling));
@@ -9943,18 +9946,18 @@ GeneralParser<ParseHandler, Unit>::objec
         if (!nameExpr) {
           return null();
         }
 
         if (possibleError) {
           checkDestructuringAssignmentName(nameExpr, namePos, possibleError);
         }
 
-        if (!handler.addShorthand(literal, handler.asName(propName),
-                                  nameExpr)) {
+        if (!handler_.addShorthand(literal, handler_.asName(propName),
+                                   nameExpr)) {
           return null();
         }
       } else if (propType == PropertyType::CoverInitializedName) {
         /*
          * Support, e.g., |({x=1, y=2} = o)| as destructuring
          * shorthand with default values, as per ES6 12.14.5
          */
         Rooted<PropertyName*> name(cx_, identifierReference(yieldHandling));
@@ -10001,22 +10004,22 @@ GeneralParser<ParseHandler, Unit>::objec
         }
 
         Node rhs = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
         if (!rhs) {
           return null();
         }
 
         BinaryNodeType propExpr =
-            handler.newAssignment(ParseNodeKind::AssignExpr, lhs, rhs);
+            handler_.newAssignment(ParseNodeKind::AssignExpr, lhs, rhs);
         if (!propExpr) {
           return null();
         }
 
-        if (!handler.addPropertyDefinition(literal, propName, propExpr)) {
+        if (!handler_.addPropertyDefinition(literal, propName, propExpr)) {
           return null();
         }
       } else {
         RootedAtom funName(cx_);
         if (!anyChars.isCurrentTokenType(TokenKind::RightBracket)) {
           funName = propAtom;
 
           if (propType == PropertyType::Getter ||
@@ -10030,18 +10033,18 @@ GeneralParser<ParseHandler, Unit>::objec
 
         FunctionNodeType funNode =
             methodDefinition(namePos.begin, propType, funName);
         if (!funNode) {
           return null();
         }
 
         AccessorType atype = ToAccessorType(propType);
-        if (!handler.addObjectMethodDefinition(literal, propName, funNode,
-                                               atype)) {
+        if (!handler_.addObjectMethodDefinition(literal, propName, funNode,
+                                                atype)) {
           return null();
         }
 
         if (possibleError) {
           possibleError->setPendingDestructuringErrorAt(
               namePos, JSMSG_BAD_DESTRUCT_TARGET);
         }
       }
@@ -10065,17 +10068,17 @@ GeneralParser<ParseHandler, Unit>::objec
                       [this, openedPos](TokenKind actual) {
                         this->reportMissingClosing(JSMSG_CURLY_AFTER_LIST,
                                                    JSMSG_CURLY_OPENED,
                                                    openedPos);
                       })) {
     return null();
   }
 
-  handler.setEndPosition(literal, pos().end);
+  handler_.setEndPosition(literal, pos().end);
   return literal;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::methodDefinition(uint32_t toStringStart,
                                                     PropertyType propType,
                                                     HandleAtom funName) {
@@ -10115,33 +10118,33 @@ GeneralParser<ParseHandler, Unit>::metho
 
   FunctionAsyncKind asyncKind = (propType == PropertyType::AsyncMethod ||
                                  propType == PropertyType::AsyncGeneratorMethod)
                                     ? FunctionAsyncKind::AsyncFunction
                                     : FunctionAsyncKind::SyncFunction;
 
   YieldHandling yieldHandling = GetYieldHandling(generatorKind);
 
-  FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
+  FunctionNodeType funNode = handler_.newFunction(syntaxKind, pos());
   if (!funNode) {
     return null();
   }
 
   return functionDefinition(funNode, toStringStart, InAllowed, yieldHandling,
                             funName, syntaxKind, generatorKind, asyncKind);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::tryNewTarget(
     BinaryNodeType* newTarget) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::New));
 
   *newTarget = null();
 
-  NullaryNodeType newHolder = handler.newPosHolder(pos());
+  NullaryNodeType newHolder = handler_.newPosHolder(pos());
   if (!newHolder) {
     return false;
   }
 
   uint32_t begin = pos().begin;
 
   // |new| expects to look for an operand, so we will honor that.
   TokenKind next;
@@ -10164,32 +10167,32 @@ bool GeneralParser<ParseHandler, Unit>::
     return false;
   }
 
   if (!pc_->sc()->allowNewTarget()) {
     errorAt(begin, JSMSG_BAD_NEWTARGET);
     return false;
   }
 
-  NullaryNodeType targetHolder = handler.newPosHolder(pos());
+  NullaryNodeType targetHolder = handler_.newPosHolder(pos());
   if (!targetHolder) {
     return false;
   }
 
-  *newTarget = handler.newNewTarget(newHolder, targetHolder);
+  *newTarget = handler_.newNewTarget(newHolder, targetHolder);
   return !!*newTarget;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::importExpr(YieldHandling yieldHandling,
                                               bool allowCallSyntax) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Import));
 
-  NullaryNodeType importHolder = handler.newPosHolder(pos());
+  NullaryNodeType importHolder = handler_.newPosHolder(pos());
   if (!importHolder) {
     return null();
   }
 
   TokenKind next;
   if (!tokenStream.getToken(&next)) {
     return null();
   }
@@ -10203,39 +10206,39 @@ GeneralParser<ParseHandler, Unit>::impor
       return null();
     }
 
     if (parseGoal() != ParseGoal::Module) {
       errorAt(pos().begin, JSMSG_IMPORT_META_OUTSIDE_MODULE);
       return null();
     }
 
-    NullaryNodeType metaHolder = handler.newPosHolder(pos());
+    NullaryNodeType metaHolder = handler_.newPosHolder(pos());
     if (!metaHolder) {
       return null();
     }
 
-    return handler.newImportMeta(importHolder, metaHolder);
+    return handler_.newImportMeta(importHolder, metaHolder);
   } else if (next == TokenKind::LeftParen && allowCallSyntax) {
     Node arg = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
     if (!arg) {
       return null();
     }
 
     if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                         JSMSG_PAREN_AFTER_ARGS)) {
       return null();
     }
 
     if (!cx_->runtime()->moduleDynamicImportHook) {
       error(JSMSG_NO_DYNAMIC_IMPORT);
       return null();
     }
 
-    return handler.newCallImport(importHolder, arg);
+    return handler_.newCallImport(importHolder, arg);
   } else {
     error(JSMSG_UNEXPECTED_TOKEN_NO_EXPECT, TokenKindToDesc(next));
     return null();
   }
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::primaryExpr(
@@ -10280,30 +10283,30 @@ typename ParseHandler::Node GeneralParse
           error(JSMSG_UNEXPECTED_TOKEN, "expression",
                 TokenKindToDesc(TokenKind::RightParen));
           return null();
         }
 
         // Now just return something that will allow parsing to continue.
         // It doesn't matter what; when we reach the =>, we will rewind and
         // reparse the whole arrow function. See Parser::assignExpr.
-        return handler.newNullLiteral(pos());
+        return handler_.newNullLiteral(pos());
       }
 
       // Pass |possibleError| to support destructuring in arrow parameters.
       Node expr = exprInParens(InAllowed, yieldHandling, TripledotAllowed,
                                possibleError);
       if (!expr) {
         return null();
       }
       if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                           JSMSG_PAREN_IN_PAREN)) {
         return null();
       }
-      return handler.parenthesize(expr);
+      return handler_.parenthesize(expr);
     }
 
     case TokenKind::TemplateHead:
       return templateLiteral(yieldHandling);
 
     case TokenKind::NoSubsTemplate:
       return noSubstitutionUntaggedTemplate();
 
@@ -10343,34 +10346,34 @@ typename ParseHandler::Node GeneralParse
 
     case TokenKind::Number:
       return newNumber(anyChars.currentToken());
 
     case TokenKind::BigInt:
       return newBigInt();
 
     case TokenKind::True:
-      return handler.newBooleanLiteral(true, pos());
+      return handler_.newBooleanLiteral(true, pos());
     case TokenKind::False:
-      return handler.newBooleanLiteral(false, pos());
+      return handler_.newBooleanLiteral(false, pos());
     case TokenKind::This: {
       if (pc_->isFunctionBox()) {
         pc_->functionBox()->usesThis = true;
       }
       NameNodeType thisName = null();
       if (pc_->sc()->thisBinding() == ThisBinding::Function) {
         thisName = newThisName();
         if (!thisName) {
           return null();
         }
       }
-      return handler.newThisLiteral(pos(), thisName);
+      return handler_.newThisLiteral(pos(), thisName);
     }
     case TokenKind::Null:
-      return handler.newNullLiteral(pos());
+      return handler_.newNullLiteral(pos());
 
     case TokenKind::TripleDot: {
       // This isn't valid expression syntax, but it's valid in an arrow
       // function as a trailing rest param: `(a, b, ...rest) => body`.  Check
       // if it's directly under
       // CoverParenthesizedExpressionAndArrowParameterList, and check for a
       // name, closing parenthesis, and arrow, and allow it only if all are
       // present.
@@ -10422,17 +10425,17 @@ typename ParseHandler::Node GeneralParse
               TokenKindToDesc(next));
         return null();
       }
 
       anyChars.ungetToken();  // put back right paren
 
       // Return an arbitrary expression node. See case TokenKind::RightParen
       // above.
-      return handler.newNullLiteral(pos());
+      return handler_.newNullLiteral(pos());
     }
   }
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::exprInParens(
     InHandling inHandling, YieldHandling yieldHandling,
     TripledotHandling tripledotHandling,
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -451,17 +451,17 @@ class MOZ_STACK_CLASS PerHandlerParser :
 
 #define DECLARE_TYPE(typeName, longTypeName, asMethodName) \
   using longTypeName = typename ParseHandler::longTypeName;
   FOR_EACH_PARSENODE_SUBCLASS(DECLARE_TYPE)
 #undef DECLARE_TYPE
 
  protected:
   /* State specific to the kind of parse being performed. */
-  ParseHandler handler;
+  ParseHandler handler_;
 
   // When ParseHandler is FullParseHandler:
   //
   //   If non-null, this field holds the syntax parser used to attempt lazy
   //   parsing of inner functions. If null, then lazy parsing is disabled.
   //
   // When ParseHandler is SyntaxParseHandler:
   //
@@ -511,17 +511,17 @@ class MOZ_STACK_CLASS PerHandlerParser :
 
   bool noteDestructuredPositionalFormalParameter(FunctionNodeType funNode,
                                                  Node destruct);
 
   bool noteUsedName(HandlePropertyName name) {
     // If the we are delazifying, the LazyScript already has all the
     // closed-over info for bindings and there's no need to track used
     // names.
-    if (handler.canSkipLazyClosedOverBindings()) {
+    if (handler_.canSkipLazyClosedOverBindings()) {
       return true;
     }
 
     return ParserBase::noteUsedNameInternal(name);
   }
 
   // Required on Scope exit.
   bool propagateFreeNamesAndMarkClosedOverBindings(ParseContext::Scope& scope);
@@ -577,21 +577,21 @@ class MOZ_STACK_CLASS PerHandlerParser :
   inline void clearAbortedSyntaxParse();
 
  public:
   bool isValidSimpleAssignmentTarget(
       Node node,
       FunctionCallBehavior behavior = ForbidAssignmentToFunctionCalls);
 
   NameNodeType newPropertyName(PropertyName* key, const TokenPos& pos) {
-    return handler.newPropertyName(key, pos);
+    return handler_.newPropertyName(key, pos);
   }
 
   PropertyAccessType newPropertyAccess(Node expr, NameNodeType key) {
-    return handler.newPropertyAccess(expr, key);
+    return handler_.newPropertyAccess(expr, key);
   }
 
   FunctionBox* newFunctionBox(FunctionNodeType funNode, JSFunction* fun,
                               uint32_t toStringStart, Directives directives,
                               GeneratorKind generatorKind,
                               FunctionAsyncKind asyncKind);
 
  public:
@@ -779,17 +779,17 @@ class MOZ_STACK_CLASS GeneralParser : pu
   using Base::warningNoOffset;
   using Base::warningWithNotes;
   using Base::warningWithNotesAt;
   using Base::warningWithNotesNoOffset;
 
  public:
   using Base::anyChars;
   using Base::cx_;
-  using Base::handler;
+  using Base::handler_;
   using Base::isValidSimpleAssignmentTarget;
   using Base::pc_;
   using Base::usedNames_;
 
  private:
   using Base::checkAndMarkSuperScope;
   using Base::declareDotGeneratorName;
   using Base::declareFunctionArgumentsObject;
@@ -1381,17 +1381,17 @@ class MOZ_STACK_CLASS GeneralParser : pu
       TargetBehavior behavior = TargetBehavior::PermitAssignmentPattern);
   void checkDestructuringAssignmentName(NameNodeType name, TokenPos namePos,
                                         PossibleError* possibleError);
   bool checkDestructuringAssignmentElement(Node expr, TokenPos exprPos,
                                            PossibleError* exprPossibleError,
                                            PossibleError* possibleError);
 
   NumericLiteralType newNumber(const Token& tok) {
-    return handler.newNumber(tok.number(), tok.decimalPoint(), tok.pos);
+    return handler_.newNumber(tok.number(), tok.decimalPoint(), tok.pos);
   }
 
   inline BigIntLiteralType newBigInt();
 
  protected:
   // Match the current token against the BindingIdentifier production with
   // the given Yield parameter.  If there is no match, report a syntax
   // error.
@@ -1488,17 +1488,17 @@ class MOZ_STACK_CLASS Parser<SyntaxParse
 
  private:
   using Base::alloc_;
 #if DEBUG
   using Base::checkOptionsCalled_;
 #endif
   using Base::finishFunctionScopes;
   using Base::functionFormalParametersAndBody;
-  using Base::handler;
+  using Base::handler_;
   using Base::innerFunction;
   using Base::keepAtoms_;
   using Base::matchOrInsertSemicolon;
   using Base::mustMatchToken;
   using Base::newFunctionBox;
   using Base::newLexicalScopeData;
   using Base::newModuleScopeData;
   using Base::newName;
@@ -1594,17 +1594,17 @@ class MOZ_STACK_CLASS Parser<FullParseHa
 
   // Inherited functions, listed here to have non-dependent names.
 
  public:
   using Base::anyChars;
   using Base::clearAbortedSyntaxParse;
   using Base::functionFormalParametersAndBody;
   using Base::hadAbortedSyntaxParse;
-  using Base::handler;
+  using Base::handler_;
   using Base::newFunctionBox;
   using Base::options;
   using Base::pc_;
   using Base::pos;
   using Base::ss;
   using Base::tokenStream;
 
  public:
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -6009,17 +6009,17 @@ static bool ParseFunction(ModuleValidato
                    // m.fail.
   }
 
   RootedPropertyName name(m.cx(), m.parser().bindingIdentifier(YieldIsName));
   if (!name) {
     return false;
   }
 
-  FunctionNode* funNode = m.parser().handler.newFunction(
+  FunctionNode* funNode = m.parser().handler_.newFunction(
       FunctionSyntaxKind::Statement, m.parser().pos());
   if (!funNode) {
     return false;
   }
 
   RootedFunction& fun = m.dummyFunction();
   fun->setAtom(name);
   fun->setArgCount(0);