Bug 1528837 - Part 5: Rename ParserBase::pc field to pc_. r=Yoric
authorTooru Fujisawa <arai_a@mac.com>
Sun, 24 Feb 2019 03:27:55 +0000
changeset 518652 1703de7ce9a0
parent 518651 3bcda710f6bd
child 518653 bc91af3d40a4
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 5: Rename ParserBase::pc field to pc_. r=Yoric Differential Revision: https://phabricator.services.mozilla.com/D20217
js/src/frontend/ParseContext-inl.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
js/src/wasm/AsmJS.cpp
--- a/js/src/frontend/ParseContext-inl.h
+++ b/js/src/frontend/ParseContext-inl.h
@@ -35,30 +35,30 @@ inline ParseContext::Scope::BindingIter 
   // In function scopes with parameter expressions, function special names
   // (like '.this') are declared as vars in the function scope, despite its
   // not being the var scope.
   return BindingIter(*this, pc->varScope_ == this ||
                                 pc->functionScope_.ptrOr(nullptr) == this);
 }
 
 inline ParseContext::Scope::Scope(ParserBase* parser)
-    : Nestable<Scope>(&parser->pc->innermostScope_),
+    : Nestable<Scope>(&parser->pc_->innermostScope_),
       declared_(parser->cx_->frontendCollectionPool()),
       possibleAnnexBFunctionBoxes_(parser->cx_->frontendCollectionPool()),
       id_(parser->usedNames.nextScopeId()) {}
 
 inline ParseContext::Scope::Scope(JSContext* cx, ParseContext* pc,
                                   UsedNameTracker& usedNames)
     : Nestable<Scope>(&pc->innermostScope_),
       declared_(cx->frontendCollectionPool()),
       possibleAnnexBFunctionBoxes_(cx->frontendCollectionPool()),
       id_(usedNames.nextScopeId()) {}
 
 inline ParseContext::VarScope::VarScope(ParserBase* parser) : Scope(parser) {
-  useAsVarScope(parser->pc);
+  useAsVarScope(parser->pc_);
 }
 
 inline ParseContext::VarScope::VarScope(JSContext* cx, ParseContext* pc,
                                         UsedNameTracker& usedNames)
     : Scope(cx, pc, usedNames) {
   useAsVarScope(pc);
 }
 
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -139,17 +139,17 @@ ParserBase::ParserBase(JSContext* cx, Li
                        const ReadOnlyCompileOptions& options,
                        bool foldConstants, UsedNameTracker& usedNames,
                        ScriptSourceObject* sourceObject, ParseGoal parseGoal)
     : AutoGCRooter(cx, AutoGCRooter::Tag::Parser),
       cx_(cx),
       alloc_(alloc),
       anyChars(cx, options, thisForCtor()),
       traceListHead_(nullptr),
-      pc(nullptr),
+      pc_(nullptr),
       usedNames(usedNames),
       ss(nullptr),
       sourceObject(cx, sourceObject),
       keepAtoms(cx),
       foldConstants(foldConstants),
 #ifdef DEBUG
       checkOptionsCalled(false),
 #endif
@@ -369,17 +369,17 @@ typename ParseHandler::ListNodeType Gene
   GlobalSharedContext globalsc(cx_, ScopeKind::Global, directives,
                                options().extraWarningsOption);
   SourceParseContext globalpc(this, &globalsc, /* newDirectives = */ nullptr);
   if (!globalpc.init()) {
     return null();
   }
 
   ParseContext::VarScope varScope(this);
-  if (!varScope.init(pc)) {
+  if (!varScope.init(pc_)) {
     return null();
   }
 
   ListNodeType stmtList = statementList(YieldIsName);
   if (!stmtList) {
     return null();
   }
 
@@ -390,17 +390,17 @@ typename ParseHandler::ListNodeType Gene
   if (tt != TokenKind::Eof) {
     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 (!pc_->useAsmOrInsideUseAsm()) {
       if (!FoldConstants(cx_, &node, &handler)) {
         return null();
       }
     }
     stmtList = handler.asList(node);
   }
 
   return stmtList;
@@ -419,51 +419,51 @@ bool ParserBase::isValidStrictBinding(Pr
          tt != TokenKind::Yield && !TokenKindIsStrictReservedWord(tt);
 }
 
 /*
  * Returns true if all parameter names are valid strict mode binding names and
  * no duplicate parameter names are present.
  */
 bool ParserBase::hasValidSimpleStrictParameterNames() {
-  MOZ_ASSERT(pc->isFunctionBox() &&
-             pc->functionBox()->hasSimpleParameterList());
-
-  if (pc->functionBox()->hasDuplicateParameters) {
+  MOZ_ASSERT(pc_->isFunctionBox() &&
+             pc_->functionBox()->hasSimpleParameterList());
+
+  if (pc_->functionBox()->hasDuplicateParameters) {
     return false;
   }
 
-  for (auto* name : pc->positionalFormalParameterNames()) {
+  for (auto* name : pc_->positionalFormalParameterNames()) {
     MOZ_ASSERT(name);
     if (!isValidStrictBinding(name->asPropertyName())) {
       return false;
     }
   }
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 void GeneralParser<ParseHandler, Unit>::reportMissingClosing(
     unsigned errorNumber, unsigned noteNumber, uint32_t openedPos) {
   auto notes = MakeUnique<JSErrorNotes>();
   if (!notes) {
-    ReportOutOfMemory(pc->sc()->cx_);
+    ReportOutOfMemory(pc_->sc()->cx_);
     return;
   }
 
   uint32_t line, column;
   tokenStream.computeLineAndColumn(openedPos, &line, &column);
 
   const size_t MaxWidth = sizeof("4294967295");
   char columnNumber[MaxWidth];
   SprintfLiteral(columnNumber, "%" PRIu32, column);
   char lineNumber[MaxWidth];
   SprintfLiteral(lineNumber, "%" PRIu32, line);
 
-  if (!notes->addNoteASCII(pc->sc()->cx_, getFilename(), line, column,
+  if (!notes->addNoteASCII(pc_->sc()->cx_, getFilename(), line, column,
                            GetErrorMessage, nullptr, noteNumber, lineNumber,
                            columnNumber)) {
     return;
   }
 
   errorWithNotes(std::move(notes), errorNumber);
 }
 
@@ -479,30 +479,30 @@ void GeneralParser<ParseHandler, Unit>::
   if (prevPos == DeclaredNameInfo::npos) {
     errorAt(pos.begin, JSMSG_REDECLARED_VAR, DeclarationKindString(prevKind),
             bytes.get());
     return;
   }
 
   auto notes = MakeUnique<JSErrorNotes>();
   if (!notes) {
-    ReportOutOfMemory(pc->sc()->cx_);
+    ReportOutOfMemory(pc_->sc()->cx_);
     return;
   }
 
   uint32_t line, column;
   tokenStream.computeLineAndColumn(prevPos, &line, &column);
 
   const size_t MaxWidth = sizeof("4294967295");
   char columnNumber[MaxWidth];
   SprintfLiteral(columnNumber, "%" PRIu32, column);
   char lineNumber[MaxWidth];
   SprintfLiteral(lineNumber, "%" PRIu32, line);
 
-  if (!notes->addNoteASCII(pc->sc()->cx_, getFilename(), line, column,
+  if (!notes->addNoteASCII(pc_->sc()->cx_, getFilename(), line, column,
                            GetErrorMessage, nullptr, JSMSG_REDECLARED_PREV,
                            lineNumber, columnNumber)) {
     return;
   }
 
   errorWithNotesAt(std::move(notes), pos.begin, JSMSG_REDECLARED_VAR,
                    DeclarationKindString(prevKind), bytes.get());
 }
@@ -516,45 +516,45 @@ void GeneralParser<ParseHandler, Unit>::
 // (ECMA-262 requires us to support duplicate parameter names, but, for newer
 // features, we consider the code to have "opted in" to higher standards and
 // forbid duplicates.)
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::notePositionalFormalParameter(
     FunctionNodeType funNode, HandlePropertyName name, uint32_t beginPos,
     bool disallowDuplicateParams, bool* duplicatedParam) {
   if (AddDeclaredNamePtr p =
-          pc->functionScope().lookupDeclaredNameForAdd(name)) {
+          pc_->functionScope().lookupDeclaredNameForAdd(name)) {
     if (disallowDuplicateParams) {
       error(JSMSG_BAD_DUP_ARGS);
       return false;
     }
 
     // Strict-mode disallows duplicate args. We may not know whether we are
     // in strict mode or not (since the function body hasn't been parsed).
     // In such cases, report will queue up the potential error and return
     // 'true'.
-    if (pc->sc()->needStrictChecks()) {
+    if (pc_->sc()->needStrictChecks()) {
       UniqueChars bytes = AtomToPrintableString(cx_, name);
       if (!bytes) {
         return false;
       }
       if (!strictModeError(JSMSG_DUPLICATE_FORMAL, bytes.get())) {
         return false;
       }
     }
 
     *duplicatedParam = true;
   } else {
     DeclarationKind kind = DeclarationKind::PositionalFormalParameter;
-    if (!pc->functionScope().addDeclaredName(pc, p, name, kind, beginPos)) {
+    if (!pc_->functionScope().addDeclaredName(pc_, p, name, kind, beginPos)) {
       return false;
     }
   }
 
-  if (!pc->positionalFormalParameterNames().append(name)) {
+  if (!pc_->positionalFormalParameterNames().append(name)) {
     ReportOutOfMemory(cx_);
     return false;
   }
 
   NameNodeType paramNode = newName(name);
   if (!paramNode) {
     return false;
   }
@@ -563,17 +563,17 @@ bool GeneralParser<ParseHandler, Unit>::
   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)) {
+  if (!pc_->positionalFormalParameterNames().append(nullptr)) {
     ReportOutOfMemory(cx_);
     return false;
   }
 
   handler.addFunctionFormalParameter(funNode, destruct);
   return true;
 }
 
@@ -599,108 +599,110 @@ bool GeneralParser<ParseHandler, Unit>::
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::noteDeclaredName(
     HandlePropertyName name, DeclarationKind kind, TokenPos pos) {
   // The asm.js validator does all its own symbol-table management so, as an
   // optimization, avoid doing any work here.
-  if (pc->useAsmOrInsideUseAsm()) {
+  if (pc_->useAsmOrInsideUseAsm()) {
     return true;
   }
 
   switch (kind) {
     case DeclarationKind::Var:
     case DeclarationKind::BodyLevelFunction: {
       Maybe<DeclarationKind> redeclaredKind;
       uint32_t prevPos;
-      if (!pc->tryDeclareVar(name, kind, pos.begin, &redeclaredKind,
-                             &prevPos)) {
+      if (!pc_->tryDeclareVar(name, kind, pos.begin, &redeclaredKind,
+                              &prevPos)) {
         return false;
       }
 
       if (redeclaredKind) {
         reportRedeclaration(name, *redeclaredKind, pos, prevPos);
         return false;
       }
 
       break;
     }
 
     case DeclarationKind::ModuleBodyLevelFunction: {
-      MOZ_ASSERT(pc->atModuleLevel());
-
-      AddDeclaredNamePtr p = pc->varScope().lookupDeclaredNameForAdd(name);
+      MOZ_ASSERT(pc_->atModuleLevel());
+
+      AddDeclaredNamePtr p = pc_->varScope().lookupDeclaredNameForAdd(name);
       if (p) {
         reportRedeclaration(name, p->value()->kind(), pos, p->value()->pos());
         return false;
       }
 
-      if (!pc->varScope().addDeclaredName(pc, p, name, kind, pos.begin)) {
+      if (!pc_->varScope().addDeclaredName(pc_, p, name, kind, pos.begin)) {
         return false;
       }
 
       // Body-level functions in modules are always closed over.
-      pc->varScope().lookupDeclaredName(name)->value()->setClosedOver();
+      pc_->varScope().lookupDeclaredName(name)->value()->setClosedOver();
 
       break;
     }
 
     case DeclarationKind::FormalParameter: {
       // It is an early error if any non-positional formal parameter name
       // (e.g., destructuring formal parameter) is duplicated.
 
-      AddDeclaredNamePtr p = pc->functionScope().lookupDeclaredNameForAdd(name);
+      AddDeclaredNamePtr p =
+          pc_->functionScope().lookupDeclaredNameForAdd(name);
       if (p) {
         error(JSMSG_BAD_DUP_ARGS);
         return false;
       }
 
-      if (!pc->functionScope().addDeclaredName(pc, p, name, kind, pos.begin)) {
+      if (!pc_->functionScope().addDeclaredName(pc_, p, name, kind,
+                                                pos.begin)) {
         return false;
       }
 
       break;
     }
 
     case DeclarationKind::LexicalFunction: {
-      ParseContext::Scope* scope = pc->innermostScope();
+      ParseContext::Scope* scope = pc_->innermostScope();
       AddDeclaredNamePtr p = scope->lookupDeclaredNameForAdd(name);
       if (p) {
         reportRedeclaration(name, p->value()->kind(), pos, p->value()->pos());
         return false;
       }
 
-      if (!scope->addDeclaredName(pc, p, name, kind, pos.begin)) {
+      if (!scope->addDeclaredName(pc_, p, name, kind, pos.begin)) {
         return false;
       }
 
       break;
     }
 
     case DeclarationKind::SloppyLexicalFunction: {
       // Functions in block have complex allowances in sloppy mode for being
       // labelled that other lexical declarations do not have. Those checks
       // are more complex than calling checkLexicalDeclarationDirectlyWithin-
       // Block and are done in checkFunctionDefinition.
 
-      ParseContext::Scope* scope = pc->innermostScope();
+      ParseContext::Scope* scope = pc_->innermostScope();
       if (AddDeclaredNamePtr p = scope->lookupDeclaredNameForAdd(name)) {
         // It is usually an early error if there is another declaration
         // with the same name in the same scope.
         //
         // Sloppy lexical functions may redeclare other sloppy lexical
         // functions for web compatibility reasons.
         if (p->value()->kind() != DeclarationKind::SloppyLexicalFunction) {
           reportRedeclaration(name, p->value()->kind(), pos, p->value()->pos());
           return false;
         }
       } else {
-        if (!scope->addDeclaredName(pc, p, name, kind, pos.begin)) {
+        if (!scope->addDeclaredName(pc_, p, name, kind, pos.begin)) {
           return false;
         }
       }
 
       break;
     }
 
     case DeclarationKind::Let:
@@ -719,45 +721,45 @@ bool GeneralParser<ParseHandler, Unit>::
     case DeclarationKind::Import:
       // Module code is always strict, so 'let' is always a keyword and never a
       // name.
       MOZ_ASSERT(name != cx_->names().let);
       MOZ_FALLTHROUGH;
 
     case DeclarationKind::SimpleCatchParameter:
     case DeclarationKind::CatchParameter: {
-      if (ParseContext::Statement* stmt = pc->innermostStatement()) {
+      if (ParseContext::Statement* stmt = pc_->innermostStatement()) {
         if (!checkLexicalDeclarationDirectlyWithinBlock(*stmt, kind, pos)) {
           return false;
         }
       }
 
-      ParseContext::Scope* scope = pc->innermostScope();
+      ParseContext::Scope* scope = pc_->innermostScope();
 
       // For body-level lexically declared names in a function, it is an
       // early error if there is a formal parameter of the same name. This
       // needs a special check if there is an extra var scope due to
       // parameter expressions.
-      if (pc->isFunctionExtraBodyVarScopeInnermost()) {
-        DeclaredNamePtr p = pc->functionScope().lookupDeclaredName(name);
+      if (pc_->isFunctionExtraBodyVarScopeInnermost()) {
+        DeclaredNamePtr p = pc_->functionScope().lookupDeclaredName(name);
         if (p && DeclarationKindIsParameter(p->value()->kind())) {
           reportRedeclaration(name, p->value()->kind(), pos, p->value()->pos());
           return false;
         }
       }
 
       // It is an early error if there is another declaration with the same
       // name in the same scope.
       AddDeclaredNamePtr p = scope->lookupDeclaredNameForAdd(name);
       if (p) {
         reportRedeclaration(name, p->value()->kind(), pos, p->value()->pos());
         return false;
       }
 
-      if (!scope->addDeclaredName(pc, p, name, kind, pos.begin)) {
+      if (!scope->addDeclaredName(pc_, p, name, kind, pos.begin)) {
         return false;
       }
 
       break;
     }
 
     case DeclarationKind::CoverArrowParameter:
       // CoverArrowParameter is only used as a placeholder declaration kind.
@@ -777,79 +779,79 @@ bool GeneralParser<ParseHandler, Unit>::
   }
 
   return true;
 }
 
 bool ParserBase::noteUsedNameInternal(HandlePropertyName name) {
   // The asm.js validator does all its own symbol-table management so, as an
   // optimization, avoid doing any work here.
-  if (pc->useAsmOrInsideUseAsm()) {
+  if (pc_->useAsmOrInsideUseAsm()) {
     return true;
   }
 
   // Global bindings are properties and not actual bindings; we don't need
   // to know if they are closed over. So no need to track used name at the
   // global scope. It is not incorrect to track them, this is an
   // optimization.
-  ParseContext::Scope* scope = pc->innermostScope();
-  if (pc->sc()->isGlobalContext() && scope == &pc->varScope()) {
+  ParseContext::Scope* scope = pc_->innermostScope();
+  if (pc_->sc()->isGlobalContext() && scope == &pc_->varScope()) {
     return true;
   }
 
-  return usedNames.noteUse(cx_, name, pc->scriptId(), scope->id());
+  return usedNames.noteUse(cx_, name, pc_->scriptId(), scope->id());
 }
 
 bool ParserBase::hasUsedName(HandlePropertyName name) {
   if (UsedNamePtr p = usedNames.lookup(name)) {
-    return p->value().isUsedInScript(pc->scriptId());
+    return p->value().isUsedInScript(pc_->scriptId());
   }
   return false;
 }
 
 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)) {
+  if (!scope.propagateAndMarkAnnexBFunctionBoxes(pc_)) {
     return false;
   }
 
   if (handler.canSkipLazyClosedOverBindings()) {
     // Scopes are nullptr-delimited in the LazyScript closed over bindings
     // array.
     while (JSAtom* name = handler.nextLazyClosedOverBinding()) {
       scope.lookupDeclaredName(name)->value()->setClosedOver();
     }
     return true;
   }
 
   bool isSyntaxParser =
       mozilla::IsSame<ParseHandler, SyntaxParseHandler>::value;
-  uint32_t scriptId = pc->scriptId();
+  uint32_t scriptId = pc_->scriptId();
   uint32_t scopeId = scope.id();
-  for (BindingIter bi = scope.bindings(pc); bi; bi++) {
+  for (BindingIter bi = scope.bindings(pc_); bi; bi++) {
     if (UsedNamePtr p = usedNames.lookup(bi.name())) {
       bool closedOver;
       p->value().noteBoundInScope(scriptId, scopeId, &closedOver);
       if (closedOver) {
         bi.setClosedOver();
 
         if (isSyntaxParser &&
-            !pc->closedOverBindingsForLazy().append(bi.name())) {
+            !pc_->closedOverBindingsForLazy().append(bi.name())) {
           ReportOutOfMemory(cx_);
           return false;
         }
       }
     }
   }
 
   // Append a nullptr to denote end-of-scope.
-  if (isSyntaxParser && !pc->closedOverBindingsForLazy().append(nullptr)) {
+  if (isSyntaxParser && !pc_->closedOverBindingsForLazy().append(nullptr)) {
     ReportOutOfMemory(cx_);
     return false;
   }
 
   return true;
 }
 
 template <typename Unit>
@@ -990,17 +992,17 @@ Maybe<GlobalScope::Data*> NewGlobalScope
                           &GlobalScope::Data::constStart, consts);
   }
 
   return Some(bindings);
 }
 
 Maybe<GlobalScope::Data*> ParserBase::newGlobalScopeData(
     ParseContext::Scope& scope) {
-  return NewGlobalScopeData(cx_, scope, alloc_, pc);
+  return NewGlobalScopeData(cx_, scope, alloc_, pc_);
 }
 
 Maybe<ModuleScope::Data*> NewModuleScopeData(JSContext* cx,
                                              ParseContext::Scope& scope,
                                              LifoAlloc& alloc,
                                              ParseContext* pc) {
   BindingNameVector imports(cx);
   BindingNameVector vars(cx);
@@ -1055,17 +1057,17 @@ Maybe<ModuleScope::Data*> NewModuleScope
                           &ModuleScope::Data::constStart, consts);
   }
 
   return Some(bindings);
 }
 
 Maybe<ModuleScope::Data*> ParserBase::newModuleScopeData(
     ParseContext::Scope& scope) {
-  return NewModuleScopeData(cx_, scope, alloc_, pc);
+  return NewModuleScopeData(cx_, scope, alloc_, pc_);
 }
 
 Maybe<EvalScope::Data*> NewEvalScopeData(JSContext* cx,
                                          ParseContext::Scope& scope,
                                          LifoAlloc& alloc, ParseContext* pc) {
   BindingNameVector vars(cx);
 
   for (BindingIter bi = scope.bindings(pc); bi; bi++) {
@@ -1092,17 +1094,17 @@ Maybe<EvalScope::Data*> NewEvalScopeData
     InitializeBindingData(bindings, numBindings, vars);
   }
 
   return Some(bindings);
 }
 
 Maybe<EvalScope::Data*> ParserBase::newEvalScopeData(
     ParseContext::Scope& scope) {
-  return NewEvalScopeData(cx_, scope, alloc_, pc);
+  return NewEvalScopeData(cx_, scope, alloc_, pc_);
 }
 
 Maybe<FunctionScope::Data*> NewFunctionScopeData(JSContext* cx,
                                                  ParseContext::Scope& scope,
                                                  bool hasParameterExprs,
                                                  LifoAlloc& alloc,
                                                  ParseContext* pc) {
   BindingNameVector positionalFormals(cx);
@@ -1190,17 +1192,17 @@ Maybe<FunctionScope::Data*> NewFunctionS
                           formals, &FunctionScope::Data::varStart, vars);
   }
 
   return Some(bindings);
 }
 
 Maybe<FunctionScope::Data*> ParserBase::newFunctionScopeData(
     ParseContext::Scope& scope, bool hasParameterExprs) {
-  return NewFunctionScopeData(cx_, scope, hasParameterExprs, alloc_, pc);
+  return NewFunctionScopeData(cx_, scope, hasParameterExprs, alloc_, pc_);
 }
 
 Maybe<VarScope::Data*> NewVarScopeData(JSContext* cx,
                                        ParseContext::Scope& scope,
                                        LifoAlloc& alloc, ParseContext* pc) {
   BindingNameVector vars(cx);
 
   bool allBindingsClosedOver = pc->sc()->allBindingsClosedOver();
@@ -1225,17 +1227,17 @@ Maybe<VarScope::Data*> NewVarScopeData(J
 
     InitializeBindingData(bindings, numBindings, vars);
   }
 
   return Some(bindings);
 }
 
 Maybe<VarScope::Data*> ParserBase::newVarScopeData(ParseContext::Scope& scope) {
-  return NewVarScopeData(cx_, scope, alloc_, pc);
+  return NewVarScopeData(cx_, scope, alloc_, pc_);
 }
 
 Maybe<LexicalScope::Data*> NewLexicalScopeData(JSContext* cx,
                                                ParseContext::Scope& scope,
                                                LifoAlloc& alloc,
                                                ParseContext* pc) {
   BindingNameVector lets(cx);
   BindingNameVector consts(cx);
@@ -1278,17 +1280,17 @@ Maybe<LexicalScope::Data*> NewLexicalSco
                           &LexicalScope::Data::constStart, consts);
   }
 
   return Some(bindings);
 }
 
 Maybe<LexicalScope::Data*> ParserBase::newLexicalScopeData(
     ParseContext::Scope& scope) {
-  return NewLexicalScopeData(cx_, scope, alloc_, pc);
+  return NewLexicalScopeData(cx_, scope, alloc_, pc_);
 }
 
 template <>
 SyntaxParseHandler::LexicalScopeNodeType
 PerHandlerParser<SyntaxParseHandler>::finishLexicalScope(
     ParseContext::Scope& scope, Node body) {
   if (!propagateFreeNamesAndMarkClosedOverBindings(scope)) {
     return null();
@@ -1316,25 +1318,25 @@ template <typename Unit>
 LexicalScopeNode* Parser<FullParseHandler, Unit>::evalBody(
     EvalSharedContext* evalsc) {
   SourceParseContext evalpc(this, evalsc, /* newDirectives = */ nullptr);
   if (!evalpc.init()) {
     return nullptr;
   }
 
   ParseContext::VarScope varScope(this);
-  if (!varScope.init(pc)) {
+  if (!varScope.init(pc_)) {
     return nullptr;
   }
 
   LexicalScopeNode* body;
   {
     // All evals have an implicit non-extensible lexical scope.
     ParseContext::Scope lexicalScope(this);
-    if (!lexicalScope.init(pc)) {
+    if (!lexicalScope.init(pc_)) {
       return nullptr;
     }
 
     ParseNode* list = statementList(YieldIsName);
     if (!list) {
       return nullptr;
     }
 
@@ -1371,35 +1373,35 @@ LexicalScopeNode* Parser<FullParseHandle
                "Eval must have found an enclosing function box scope that "
                "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 (!pc_->useAsmOrInsideUseAsm()) {
     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.
-  if (!varScope.propagateAndMarkAnnexBFunctionBoxes(pc)) {
+  if (!varScope.propagateAndMarkAnnexBFunctionBoxes(pc_)) {
     return nullptr;
   }
 
-  Maybe<EvalScope::Data*> bindings = newEvalScopeData(pc->varScope());
+  Maybe<EvalScope::Data*> bindings = newEvalScopeData(pc_->varScope());
   if (!bindings) {
     return nullptr;
   }
   evalsc->bindings = *bindings;
 
   return body;
 }
 
@@ -1407,51 +1409,51 @@ template <typename Unit>
 ListNode* Parser<FullParseHandler, Unit>::globalBody(
     GlobalSharedContext* globalsc) {
   SourceParseContext globalpc(this, globalsc, /* newDirectives = */ nullptr);
   if (!globalpc.init()) {
     return nullptr;
   }
 
   ParseContext::VarScope varScope(this);
-  if (!varScope.init(pc)) {
+  if (!varScope.init(pc_)) {
     return nullptr;
   }
 
   ListNode* body = statementList(YieldIsName);
   if (!body) {
     return nullptr;
   }
 
   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 (!pc_->useAsmOrInsideUseAsm()) {
     if (!FoldConstants(cx_, &node, &handler)) {
       return null();
     }
   }
   body = &node->as<ListNode>();
 
   if (!this->setSourceMapInfo()) {
     return nullptr;
   }
 
   // For global scripts, whether bindings are closed over or not doesn't
   // matter, so no need to call propagateFreeNamesAndMarkClosedOver-
   // Bindings. However, Annex B.3.3 functions still need to be marked.
-  if (!varScope.propagateAndMarkAnnexBFunctionBoxes(pc)) {
+  if (!varScope.propagateAndMarkAnnexBFunctionBoxes(pc_)) {
     return nullptr;
   }
 
-  Maybe<GlobalScope::Data*> bindings = newGlobalScopeData(pc->varScope());
+  Maybe<GlobalScope::Data*> bindings = newGlobalScopeData(pc_->varScope());
   if (!bindings) {
     return nullptr;
   }
   globalsc->bindings = *bindings;
 
   return body;
 }
 
@@ -1461,17 +1463,17 @@ ModuleNode* Parser<FullParseHandler, Uni
   MOZ_ASSERT(checkOptionsCalled);
 
   SourceParseContext modulepc(this, modulesc, nullptr);
   if (!modulepc.init()) {
     return null();
   }
 
   ParseContext::VarScope varScope(this);
-  if (!varScope.init(pc)) {
+  if (!varScope.init(pc_)) {
     return nullptr;
   }
 
   ModuleNodeType moduleNode = handler.newModule(pos());
   if (!moduleNode) {
     return null();
   }
 
@@ -1515,17 +1517,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 (!pc_->useAsmOrInsideUseAsm()) {
     if (!FoldConstants(cx_, &node, &handler)) {
       return null();
     }
   }
   stmtList = &node->as<ListNode>();
 
   if (!this->setSourceMapInfo()) {
     return null();
@@ -1548,45 +1550,45 @@ template <typename Unit>
 SyntaxParseHandler::ModuleNodeType Parser<SyntaxParseHandler, Unit>::moduleBody(
     ModuleSharedContext* modulesc) {
   MOZ_ALWAYS_FALSE(abortIfSyntaxParser());
   return SyntaxParseHandler::NodeFailure;
 }
 
 bool ParserBase::hasUsedFunctionSpecialName(HandlePropertyName name) {
   MOZ_ASSERT(name == cx_->names().arguments || name == cx_->names().dotThis);
-  return hasUsedName(name) || pc->functionBox()->bindingsAccessedDynamically();
+  return hasUsedName(name) || pc_->functionBox()->bindingsAccessedDynamically();
 }
 
 template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::declareFunctionThis() {
   // The asm.js validator does all its own symbol-table management so, as an
   // optimization, avoid doing any work here.
-  if (pc->useAsmOrInsideUseAsm()) {
+  if (pc_->useAsmOrInsideUseAsm()) {
     return true;
   }
 
   // Derived class constructors emit JSOP_CHECKRETURN, which requires
   // '.this' to be bound.
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
   HandlePropertyName dotThis = cx_->names().dotThis;
 
   bool declareThis;
   if (handler.canSkipLazyClosedOverBindings()) {
     declareThis = funbox->function()->lazyScript()->hasThisBinding();
   } else {
     declareThis = hasUsedFunctionSpecialName(dotThis) ||
                   funbox->isDerivedClassConstructor();
   }
 
   if (declareThis) {
-    ParseContext::Scope& funScope = pc->functionScope();
+    ParseContext::Scope& funScope = pc_->functionScope();
     AddDeclaredNamePtr p = funScope.lookupDeclaredNameForAdd(dotThis);
     MOZ_ASSERT(!p);
-    if (!funScope.addDeclaredName(pc, p, dotThis, DeclarationKind::Var,
+    if (!funScope.addDeclaredName(pc_, p, dotThis, DeclarationKind::Var,
                                   DeclaredNameInfo::npos)) {
       return false;
     }
     funbox->setHasThisBinding();
   }
 
   return true;
 }
@@ -1614,76 +1616,77 @@ template <class ParseHandler>
 typename ParseHandler::NameNodeType
 PerHandlerParser<ParseHandler>::newDotGeneratorName() {
   return newInternalDotName(cx_->names().dotGenerator);
 }
 
 bool ParserBase::declareDotGeneratorName() {
   // The special '.generator' binding must be on the function scope, as
   // generators expect to find it on the CallObject.
-  ParseContext::Scope& funScope = pc->functionScope();
+  ParseContext::Scope& funScope = pc_->functionScope();
   HandlePropertyName dotGenerator = cx_->names().dotGenerator;
   AddDeclaredNamePtr p = funScope.lookupDeclaredNameForAdd(dotGenerator);
-  if (!p && !funScope.addDeclaredName(pc, p, dotGenerator, DeclarationKind::Var,
-                                      DeclaredNameInfo::npos)) {
+  if (!p &&
+      !funScope.addDeclaredName(pc_, p, dotGenerator, DeclarationKind::Var,
+                                DeclaredNameInfo::npos)) {
     return false;
   }
   return true;
 }
 
 template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::finishFunctionScopes(
     bool isStandaloneFunction) {
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
 
   if (funbox->hasParameterExprs) {
-    if (!propagateFreeNamesAndMarkClosedOverBindings(pc->functionScope())) {
+    if (!propagateFreeNamesAndMarkClosedOverBindings(pc_->functionScope())) {
       return false;
     }
   }
 
   if (funbox->function()->isNamedLambda() && !isStandaloneFunction) {
-    if (!propagateFreeNamesAndMarkClosedOverBindings(pc->namedLambdaScope())) {
+    if (!propagateFreeNamesAndMarkClosedOverBindings(pc_->namedLambdaScope())) {
       return false;
     }
   }
 
   return true;
 }
 
 template <>
 bool PerHandlerParser<FullParseHandler>::finishFunction(
     bool isStandaloneFunction /* = false */) {
   if (!finishFunctionScopes(isStandaloneFunction)) {
     return false;
   }
 
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
   bool hasParameterExprs = funbox->hasParameterExprs;
 
   if (hasParameterExprs) {
-    Maybe<VarScope::Data*> bindings = newVarScopeData(pc->varScope());
+    Maybe<VarScope::Data*> bindings = newVarScopeData(pc_->varScope());
     if (!bindings) {
       return false;
     }
     funbox->extraVarScopeBindings().set(*bindings);
   }
 
   {
     Maybe<FunctionScope::Data*> bindings =
-        newFunctionScopeData(pc->functionScope(), hasParameterExprs);
+        newFunctionScopeData(pc_->functionScope(), hasParameterExprs);
     if (!bindings) {
       return false;
     }
     funbox->functionScopeBindings().set(*bindings);
   }
 
   if (funbox->function()->isNamedLambda() && !isStandaloneFunction) {
     Maybe<LexicalScope::Data*> bindings =
-        newLexicalScopeData(pc->namedLambdaScope());
+        newLexicalScopeData(pc_->namedLambdaScope());
     if (!bindings) {
       return false;
     }
     funbox->namedLambdaBindings().set(*bindings);
   }
 
   return true;
 }
@@ -1697,38 +1700,38 @@ bool PerHandlerParser<SyntaxParseHandler
   // retain correct scope information.
 
   if (!finishFunctionScopes(isStandaloneFunction)) {
     return false;
   }
 
   // There are too many bindings or inner functions to be saved into the
   // LazyScript. Do a full parse.
-  if (pc->closedOverBindingsForLazy().length() >=
+  if (pc_->closedOverBindingsForLazy().length() >=
           LazyScript::NumClosedOverBindingsLimit ||
-      pc->innerFunctionsForLazy.length() >=
+      pc_->innerFunctionsForLazy.length() >=
           LazyScript::NumInnerFunctionsLimit) {
     MOZ_ALWAYS_FALSE(abortIfSyntaxParser());
     return false;
   }
 
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
   RootedFunction fun(cx_, funbox->function());
   LazyScript* lazy = LazyScript::Create(
-      cx_, fun, sourceObject, pc->closedOverBindingsForLazy(),
-      pc->innerFunctionsForLazy, funbox->bufStart, funbox->bufEnd,
+      cx_, fun, sourceObject, pc_->closedOverBindingsForLazy(),
+      pc_->innerFunctionsForLazy, funbox->bufStart, funbox->bufEnd,
       funbox->toStringStart, funbox->startLine, funbox->startColumn,
       parseGoal());
   if (!lazy) {
     return false;
   }
 
   // Flags that need to be copied into the JSScript when we do the full
   // parse.
-  if (pc->sc()->strict()) {
+  if (pc_->sc()->strict()) {
     lazy->setStrict();
   }
   lazy->setGeneratorKind(funbox->generatorKind());
   lazy->setAsyncKind(funbox->asyncKind());
   if (funbox->hasRest()) {
     lazy->setHasRest();
   }
   if (funbox->isLikelyConstructorWrapper()) {
@@ -1850,35 +1853,35 @@ FunctionNode* Parser<FullParseHandler, U
   if (tt != TokenKind::Eof) {
     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 (!pc_->useAsmOrInsideUseAsm()) {
     if (!FoldConstants(cx_, &node, &handler)) {
       return null();
     }
   }
   funNode = &node->as<FunctionNode>();
 
   if (!this->setSourceMapInfo()) {
     return null();
   }
 
   return funNode;
 }
 
 template <class ParseHandler>
 bool PerHandlerParser<ParseHandler>::declareFunctionArgumentsObject() {
-  FunctionBox* funbox = pc->functionBox();
-  ParseContext::Scope& funScope = pc->functionScope();
-  ParseContext::Scope& varScope = pc->varScope();
+  FunctionBox* funbox = pc_->functionBox();
+  ParseContext::Scope& funScope = pc_->functionScope();
+  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()) {
@@ -1905,17 +1908,17 @@ bool PerHandlerParser<ParseHandler>::dec
     } else {
       funbox->usesArguments = true;
     }
   }
 
   if (tryDeclareArguments) {
     AddDeclaredNamePtr p = funScope.lookupDeclaredNameForAdd(argumentsName);
     if (!p) {
-      if (!funScope.addDeclaredName(pc, p, argumentsName, DeclarationKind::Var,
+      if (!funScope.addDeclaredName(pc_, p, argumentsName, DeclarationKind::Var,
                                     DeclaredNameInfo::npos)) {
         return false;
       }
       funbox->declaredArguments = true;
       funbox->usesArguments = true;
     } else if (hasExtraBodyVarScope) {
       // Formal parameters shadow the arguments object.
       return true;
@@ -1926,100 +1929,100 @@ bool PerHandlerParser<ParseHandler>::dec
   if (funbox->usesArguments) {
     // There is an 'arguments' binding. Is the arguments object definitely
     // needed?
     //
     // Also see the flags' comments in ContextFlags.
     funbox->setArgumentsHasLocalBinding();
 
     // Dynamic scope access destroys all hope of optimization.
-    if (pc->sc()->bindingsAccessedDynamically()) {
+    if (pc_->sc()->bindingsAccessedDynamically()) {
       funbox->setDefinitelyNeedsArgsObj();
     }
 
     // If a script contains the debugger statement either directly or
     // within an inner function, the arguments object should be created
     // eagerly so the Debugger API may observe bindings.
-    if (pc->sc()->hasDebuggerStatement()) {
+    if (pc_->sc()->hasDebuggerStatement()) {
       funbox->setDefinitelyNeedsArgsObj();
     }
   }
 
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::LexicalScopeNodeType
 GeneralParser<ParseHandler, Unit>::functionBody(InHandling inHandling,
                                                 YieldHandling yieldHandling,
                                                 FunctionSyntaxKind kind,
                                                 FunctionBodyType type) {
-  MOZ_ASSERT(pc->isFunctionBox());
+  MOZ_ASSERT(pc_->isFunctionBox());
 
 #ifdef DEBUG
-  uint32_t startYieldOffset = pc->lastYieldOffset;
+  uint32_t startYieldOffset = pc_->lastYieldOffset;
 #endif
 
   Node body;
   if (type == StatementListBody) {
-    bool inheritedStrict = pc->sc()->strict();
+    bool inheritedStrict = pc_->sc()->strict();
     body = statementList(yieldHandling);
     if (!body) {
       return null();
     }
 
     // When we transitioned from non-strict to strict mode, we need to
     // validate that all parameter names are valid strict mode names.
-    if (!inheritedStrict && pc->sc()->strict()) {
-      MOZ_ASSERT(pc->sc()->hasExplicitUseStrict(),
+    if (!inheritedStrict && pc_->sc()->strict()) {
+      MOZ_ASSERT(pc_->sc()->hasExplicitUseStrict(),
                  "strict mode should only change when a 'use strict' directive "
                  "is present");
       if (!hasValidSimpleStrictParameterNames()) {
         // Request that this function be reparsed as strict to report
         // the invalid parameter name at the correct source location.
-        pc->newDirectives->setStrict();
+        pc_->newDirectives->setStrict();
         return null();
       }
     }
   } 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()) {
+    if (pc_->isAsync()) {
       stmtList = handler.newStatementList(pos());
       if (!stmtList) {
         return null();
       }
     }
 
     Node kid = assignExpr(inHandling, yieldHandling, TripledotProhibited);
     if (!kid) {
       return null();
     }
 
     body = handler.newExpressionBody(kid);
     if (!body) {
       return null();
     }
 
-    if (pc->isAsync()) {
+    if (pc_->isAsync()) {
       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);
-
-  if (pc->needsDotGeneratorName()) {
-    MOZ_ASSERT_IF(!pc->isAsync(), type == StatementListBody);
+  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);
+
+  if (pc_->needsDotGeneratorName()) {
+    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)) {
@@ -2034,17 +2037,17 @@ GeneralParser<ParseHandler, Unit>::funct
     if (!declareFunctionArgumentsObject()) {
       return null();
     }
     if (!declareFunctionThis()) {
       return null();
     }
   }
 
-  return finishLexicalScope(pc->varScope(), body);
+  return finishLexicalScope(pc_->varScope(), body);
 }
 
 JSFunction* AllocNewFunction(JSContext* cx, HandleAtom atom,
                              FunctionSyntaxKind kind,
                              GeneratorKind generatorKind,
                              FunctionAsyncKind asyncKind, HandleObject proto,
                              bool isSelfHosting /* = false */,
                              bool inFunctionBox /* = false */) {
@@ -2124,17 +2127,17 @@ JSFunction* AllocNewFunction(JSContext* 
   return fun;
 }
 
 JSFunction* ParserBase::newFunction(HandleAtom atom, FunctionSyntaxKind kind,
                                     GeneratorKind generatorKind,
                                     FunctionAsyncKind asyncKind,
                                     HandleObject proto /* = nullptr */) {
   return AllocNewFunction(cx_, atom, kind, generatorKind, asyncKind, proto,
-                          options().selfHostingMode, pc->isFunctionBox());
+                          options().selfHostingMode, pc_->isFunctionBox());
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::matchOrInsertSemicolon() {
   TokenKind tt = TokenKind::Eof;
   if (!tokenStream.peekTokenSameLine(&tt, TokenStream::Operand)) {
     return false;
   }
@@ -2147,17 +2150,17 @@ bool GeneralParser<ParseHandler, Unit>::
      *   await f();
      *        ^
      *        |
      *        tried to insert semicolon here
      *
      * Detect this situation and throw an understandable error.  Otherwise
      * we'd throw a confusing "unexpected token: (unexpected token)" error.
      */
-    if (!pc->isAsync() && anyChars.currentToken().type == TokenKind::Await) {
+    if (!pc_->isAsync() && anyChars.currentToken().type == TokenKind::Await) {
       error(JSMSG_AWAIT_OUTSIDE_ASYNC);
       return false;
     }
     if (!yieldExpressionsSupported() &&
         anyChars.currentToken().type == TokenKind::Yield) {
       error(JSMSG_YIELD_OUTSIDE_GENERATOR);
       return false;
     }
@@ -2168,41 +2171,41 @@ bool GeneralParser<ParseHandler, Unit>::
     return false;
   }
   bool matched;
   return tokenStream.matchToken(&matched, TokenKind::Semi,
                                 TokenStream::Operand);
 }
 
 bool ParserBase::leaveInnerFunction(ParseContext* outerpc) {
-  MOZ_ASSERT(pc != outerpc);
+  MOZ_ASSERT(pc_ != outerpc);
 
   // If the current function allows super.property but cannot have a home
   // object, i.e., it is an arrow function, we need to propagate the flag to
   // the outer ParseContext.
-  if (pc->superScopeNeedsHomeObject()) {
-    if (!pc->isArrowFunction()) {
-      MOZ_ASSERT(pc->functionBox()->needsHomeObject());
+  if (pc_->superScopeNeedsHomeObject()) {
+    if (!pc_->isArrowFunction()) {
+      MOZ_ASSERT(pc_->functionBox()->needsHomeObject());
     } else {
       outerpc->setSuperScopeNeedsHomeObject();
     }
   }
 
   // Lazy functions inner to another lazy function need to be remembered by
   // the inner function so that if the outer function is eventually parsed
   // we do not need any further parsing or processing of the inner function.
   //
   // Append the inner function here unconditionally; the vector is only used
   // if the Parser using outerpc is a syntax parsing. See
   // GeneralParser<SyntaxParseHandler>::finishFunction.
-  if (!outerpc->innerFunctionsForLazy.append(pc->functionBox()->function())) {
+  if (!outerpc->innerFunctionsForLazy.append(pc_->functionBox()->function())) {
     return false;
   }
 
-  PropagateTransitiveParseFlags(pc->functionBox(), outerpc->sc());
+  PropagateTransitiveParseFlags(pc_->functionBox(), outerpc->sc());
 
   return true;
 }
 
 JSAtom* ParserBase::prefixAccessorName(PropertyType propType,
                                        HandleAtom propAtom) {
   RootedAtom prefix(cx_);
   if (propType == PropertyType::Setter) {
@@ -2219,17 +2222,17 @@ JSAtom* ParserBase::prefixAccessorName(P
 
   return AtomizeString(cx_, str);
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::functionArguments(
     YieldHandling yieldHandling, FunctionSyntaxKind kind,
     FunctionNodeType funNode) {
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
 
   bool parenFreeArrow = false;
   // Modifier for the following tokens.
   // TokenStream::None for the following cases:
   //   async a => 1
   //         ^
   //
   //   (a) => 1
@@ -2315,17 +2318,17 @@ bool GeneralParser<ParseHandler, Unit>::
   }
   if (hasArguments) {
     bool hasRest = false;
     bool hasDefault = false;
     bool duplicatedParam = false;
     bool disallowDuplicateParams = kind == FunctionSyntaxKind::Arrow ||
                                    kind == FunctionSyntaxKind::Method ||
                                    kind == FunctionSyntaxKind::ClassConstructor;
-    AtomVector& positionalFormals = pc->positionalFormalParameterNames();
+    AtomVector& positionalFormals = pc_->positionalFormalParameterNames();
 
     if (kind == FunctionSyntaxKind::Getter) {
       error(JSMSG_ACCESSOR_WRONG_ARGS, "getter", "no", "s");
       return false;
     }
 
     while (true) {
       if (hasRest) {
@@ -2548,25 +2551,25 @@ bool Parser<FullParseHandler, Unit>::ski
     return false;
   }
 
   LazyScript* lazy = fun->lazyScript();
   if (lazy->needsHomeObject()) {
     funbox->setNeedsHomeObject();
   }
 
-  PropagateTransitiveParseFlags(lazy, pc->sc());
+  PropagateTransitiveParseFlags(lazy, pc_->sc());
 
   if (!tokenStream.advance(fun->lazyScript()->sourceEnd())) {
     return false;
   }
 
   // Append possible Annex B function box only upon successfully parsing.
   if (tryAnnexB &&
-      !pc->innermostScope()->addPossibleAnnexBFunctionBox(pc, funbox)) {
+      !pc_->innermostScope()->addPossibleAnnexBFunctionBox(pc_, funbox)) {
     return false;
   }
 
   return true;
 }
 
 template <typename Unit>
 bool Parser<SyntaxParseHandler, Unit>::skipLazyInnerFunction(
@@ -2694,17 +2697,17 @@ GeneralParser<ParseHandler, Unit>::funct
   if (!fun) {
     return null();
   }
 
   // Speculatively parse using the directives of the parent parsing context.
   // If a directive is encountered (e.g., "use strict") that changes how the
   // function should have been parsed, we backup and reparse with the new set
   // of directives.
-  Directives directives(pc);
+  Directives directives(pc_);
   Directives newDirectives = directives;
 
   Position start(keepAtoms, tokenStream);
 
   // Parse the inner function. The following is a loop as we may attempt to
   // reparse a function due to failed syntax parsing and encountering new
   // "use foo" directives.
   while (true) {
@@ -2770,21 +2773,21 @@ bool Parser<FullParseHandler, Unit>::try
     // still expects a FunctionBox to be attached to it during BCE, and
     // the syntax parser cannot attach one to it.
     FunctionBox* funbox =
         newFunctionBox(*funNode, fun, toStringStart, inheritedDirectives,
                        generatorKind, asyncKind);
     if (!funbox) {
       return false;
     }
-    funbox->initWithEnclosingParseContext(pc, kind);
+    funbox->initWithEnclosingParseContext(pc_, kind);
 
     SyntaxParseHandler::Node syntaxNode =
         syntaxParser->innerFunctionForFunctionBox(
-            SyntaxParseHandler::NodeGeneric, pc, funbox, inHandling,
+            SyntaxParseHandler::NodeGeneric, pc_, funbox, inHandling,
             yieldHandling, kind, newDirectives);
     if (!syntaxNode) {
       if (syntaxParser->hadAbortedSyntaxParse()) {
         // Try again with a full parse. UsedNameTracker needs to be
         // rewound to just before we tried the syntax parse for
         // correctness.
         syntaxParser->clearAbortedSyntaxParse();
         usedNames.rewind(token);
@@ -2801,27 +2804,27 @@ bool Parser<FullParseHandler, Unit>::try
       return false;
     }
 
     // Update the end position of the parse node.
     (*funNode)->pn_pos.end = anyChars.currentToken().pos.end;
 
     // Append possible Annex B function box only upon successfully parsing.
     if (tryAnnexB) {
-      if (!pc->innermostScope()->addPossibleAnnexBFunctionBox(pc, funbox)) {
+      if (!pc_->innermostScope()->addPossibleAnnexBFunctionBox(pc_, funbox)) {
         return false;
       }
     }
 
     return true;
   } while (false);
 
   // We failed to do a syntax parse above, so do the full parse.
   FunctionNodeType innerFunc = innerFunction(
-      *funNode, pc, fun, toStringStart, inHandling, yieldHandling, kind,
+      *funNode, pc_, fun, toStringStart, inHandling, yieldHandling, kind,
       generatorKind, asyncKind, tryAnnexB, inheritedDirectives, newDirectives);
   if (!innerFunc) {
     return false;
   }
 
   *funNode = innerFunc;
   return true;
 }
@@ -2829,17 +2832,17 @@ bool Parser<FullParseHandler, Unit>::try
 template <typename Unit>
 bool Parser<SyntaxParseHandler, Unit>::trySyntaxParseInnerFunction(
     FunctionNodeType* funNode, HandleFunction fun, uint32_t toStringStart,
     InHandling inHandling, YieldHandling yieldHandling, FunctionSyntaxKind kind,
     GeneratorKind generatorKind, FunctionAsyncKind asyncKind, bool tryAnnexB,
     Directives inheritedDirectives, Directives* newDirectives) {
   // This is already a syntax parser, so just parse the inner function.
   FunctionNodeType innerFunc = innerFunction(
-      *funNode, pc, fun, toStringStart, inHandling, yieldHandling, kind,
+      *funNode, pc_, fun, toStringStart, inHandling, yieldHandling, kind,
       generatorKind, asyncKind, tryAnnexB, inheritedDirectives, newDirectives);
 
   if (!innerFunc) {
     return false;
   }
 
   *funNode = innerFunc;
   return true;
@@ -2857,17 +2860,17 @@ inline bool GeneralParser<ParseHandler, 
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::innerFunctionForFunctionBox(
     FunctionNodeType funNode, ParseContext* outerpc, FunctionBox* funbox,
     InHandling inHandling, YieldHandling yieldHandling, FunctionSyntaxKind kind,
     Directives* newDirectives) {
-  // Note that it is possible for outerpc != this->pc, as we may be
+  // Note that it is possible for outerpc != this->pc_, as we may be
   // attempting to syntax parse an inner function from an outer full
   // parser. In that case, outerpc is a SourceParseContext from the full parser
   // instead of the current top of the stack of the syntax parser.
 
   // Push a new ParseContext.
   SourceParseContext funpc(this, funbox, newDirectives);
   if (!funpc.init()) {
     return null();
@@ -2888,17 +2891,17 @@ GeneralParser<ParseHandler, Unit>::inner
 template <class ParseHandler, typename Unit>
 typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::innerFunction(
     FunctionNodeType funNode, ParseContext* outerpc, HandleFunction fun,
     uint32_t toStringStart, InHandling inHandling, YieldHandling yieldHandling,
     FunctionSyntaxKind kind, GeneratorKind generatorKind,
     FunctionAsyncKind asyncKind, bool tryAnnexB, Directives inheritedDirectives,
     Directives* newDirectives) {
-  // Note that it is possible for outerpc != this->pc, as we may be
+  // Note that it is possible for outerpc != this->pc_, as we may be
   // attempting to syntax parse an inner function from an outer full
   // parser. In that case, outerpc is a SourceParseContext from the full parser
   // instead of the current top of the stack of the syntax parser.
 
   FunctionBox* funbox =
       newFunctionBox(funNode, fun, toStringStart, inheritedDirectives,
                      generatorKind, asyncKind);
   if (!funbox) {
@@ -2909,17 +2912,17 @@ GeneralParser<ParseHandler, Unit>::inner
   FunctionNodeType innerFunc = innerFunctionForFunctionBox(
       funNode, outerpc, funbox, inHandling, yieldHandling, kind, newDirectives);
   if (!innerFunc) {
     return null();
   }
 
   // Append possible Annex B function box only upon successfully parsing.
   if (tryAnnexB) {
-    if (!pc->innermostScope()->addPossibleAnnexBFunctionBox(pc, funbox)) {
+    if (!pc_->innermostScope()->addPossibleAnnexBFunctionBox(pc_, funbox)) {
       return null();
     }
   }
 
   return innerFunc;
 }
 
 template <class ParseHandler, typename Unit>
@@ -3000,17 +3003,17 @@ FunctionNode* Parser<FullParseHandler, U
                                        syntaxKind)) {
     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 (!pc_->useAsmOrInsideUseAsm()) {
     if (!FoldConstants(cx_, &node, &handler)) {
       return null();
     }
   }
   funNode = &node->as<FunctionNode>();
 
   return funNode;
 }
@@ -3020,17 +3023,17 @@ bool GeneralParser<ParseHandler, Unit>::
     InHandling inHandling, YieldHandling yieldHandling,
     FunctionNodeType* funNode, FunctionSyntaxKind kind,
     const Maybe<uint32_t>& parameterListEnd /* = Nothing() */,
     bool isStandaloneFunction /* = false */) {
   // Given a properly initialized parse context, try to parse an actual
   // function without concern for conversion to strict mode, use of lazy
   // parsing and such.
 
-  FunctionBox* funbox = pc->functionBox();
+  FunctionBox* funbox = pc_->functionBox();
   RootedFunction fun(cx_, funbox->function());
 
   // See below for an explanation why arrow function parameters and arrow
   // function bodies are parsed with different yield/await settings.
   {
     AwaitHandling awaitHandling =
         (funbox->isAsync() ||
          (kind == FunctionSyntaxKind::Arrow && awaitIsKeyword()))
@@ -3042,21 +3045,21 @@ bool GeneralParser<ParseHandler, Unit>::
     if (!functionArguments(yieldHandling, kind, *funNode)) {
       return false;
     }
   }
 
   Maybe<ParseContext::VarScope> varScope;
   if (funbox->hasParameterExprs) {
     varScope.emplace(this);
-    if (!varScope->init(pc)) {
+    if (!varScope->init(pc_)) {
       return false;
     }
   } else {
-    pc->functionScope().useAsVarScope(pc);
+    pc_->functionScope().useAsVarScope(pc_);
   }
 
   if (kind == FunctionSyntaxKind::Arrow) {
     bool matched;
     if (!tokenStream.matchToken(&matched, TokenKind::Arrow)) {
       return false;
     }
     if (!matched) {
@@ -3093,36 +3096,36 @@ bool GeneralParser<ParseHandler, Unit>::
   }
 
   // Arrow function parameters inherit yieldHandling from the enclosing
   // context, but the arrow body doesn't. E.g. in |(a = yield) => yield|,
   // |yield| in the parameters is either a name or keyword, depending on
   // whether the arrow function is enclosed in a generator function or not.
   // Whereas the |yield| in the function body is always parsed as a name.
   // The same goes when parsing |await| in arrow functions.
-  YieldHandling bodyYieldHandling = GetYieldHandling(pc->generatorKind());
-  AwaitHandling bodyAwaitHandling = GetAwaitHandling(pc->asyncKind());
-  bool inheritedStrict = pc->sc()->strict();
+  YieldHandling bodyYieldHandling = GetYieldHandling(pc_->generatorKind());
+  AwaitHandling bodyAwaitHandling = GetAwaitHandling(pc_->asyncKind());
+  bool inheritedStrict = pc_->sc()->strict();
   LexicalScopeNodeType body;
   {
     AutoAwaitIsKeyword<ParseHandler, Unit> awaitIsKeyword(this,
                                                           bodyAwaitHandling);
     AutoInParametersOfAsyncFunction<ParseHandler, Unit> inParameters(this,
                                                                      false);
     body = functionBody(inHandling, bodyYieldHandling, kind, bodyType);
     if (!body) {
       return false;
     }
   }
 
   // Revalidate the function name when we transitioned to strict mode.
   if ((kind == FunctionSyntaxKind::Statement ||
        kind == FunctionSyntaxKind::Expression) &&
-      fun->explicitName() && !inheritedStrict && pc->sc()->strict()) {
-    MOZ_ASSERT(pc->sc()->hasExplicitUseStrict(),
+      fun->explicitName() && !inheritedStrict && pc_->sc()->strict()) {
+    MOZ_ASSERT(pc_->sc()->hasExplicitUseStrict(),
                "strict mode should only change when a 'use strict' directive "
                "is present");
 
     PropertyName* propertyName = fun->explicitName()->asPropertyName();
     YieldHandling nameYieldHandling;
     if (kind == FunctionSyntaxKind::Expression) {
       // Named lambda has binding inside it.
       nameYieldHandling = bodyYieldHandling;
@@ -3167,17 +3170,17 @@ bool GeneralParser<ParseHandler, Unit>::
 
     if (kind == FunctionSyntaxKind::Statement) {
       if (!matchOrInsertSemicolon()) {
         return false;
       }
     }
   }
 
-  if (IsMethodDefinitionKind(kind) && pc->superScopeNeedsHomeObject()) {
+  if (IsMethodDefinitionKind(kind) && pc_->superScopeNeedsHomeObject()) {
     funbox->setNeedsHomeObject();
   }
 
   if (!finishFunction(isStandaloneFunction)) {
     return false;
   }
 
   handler.setEndPosition(body, pos().begin);
@@ -3192,19 +3195,19 @@ typename ParseHandler::FunctionNodeType
 GeneralParser<ParseHandler, Unit>::functionStmt(uint32_t toStringStart,
                                                 YieldHandling yieldHandling,
                                                 DefaultHandling defaultHandling,
                                                 FunctionAsyncKind asyncKind) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Function));
 
   // In sloppy mode, Annex B.3.2 allows labelled function declarations.
   // Otherwise it's a parse error.
-  ParseContext::Statement* declaredInStmt = pc->innermostStatement();
+  ParseContext::Statement* declaredInStmt = pc_->innermostStatement();
   if (declaredInStmt && declaredInStmt->kind() == StatementKind::Label) {
-    MOZ_ASSERT(!pc->sc()->strict(),
+    MOZ_ASSERT(!pc_->sc()->strict(),
                "labeled functions shouldn't be parsed in strict mode");
 
     // Find the innermost non-label statement.  Report an error if it's
     // unbraced: functions can't appear in it.  Otherwise the statement
     // (or its absence) determines the scope the function's bound in.
     while (declaredInStmt && declaredInStmt->kind() == StatementKind::Label) {
       declaredInStmt = declaredInStmt->enclosing();
     }
@@ -3245,23 +3248,23 @@ GeneralParser<ParseHandler, Unit>::funct
 
   // Note the declared name and check for early errors.
   DeclarationKind kind;
   if (declaredInStmt) {
     MOZ_ASSERT(declaredInStmt->kind() != StatementKind::Label);
     MOZ_ASSERT(StatementKindIsBraced(declaredInStmt->kind()));
 
     kind =
-        (!pc->sc()->strict() && generatorKind == GeneratorKind::NotGenerator &&
+        (!pc_->sc()->strict() && generatorKind == GeneratorKind::NotGenerator &&
          asyncKind == FunctionAsyncKind::SyncFunction)
             ? DeclarationKind::SloppyLexicalFunction
             : DeclarationKind::LexicalFunction;
   } else {
-    kind = pc->atModuleLevel() ? DeclarationKind::ModuleBodyLevelFunction
-                               : DeclarationKind::BodyLevelFunction;
+    kind = pc_->atModuleLevel() ? DeclarationKind::ModuleBodyLevelFunction
+                                : DeclarationKind::BodyLevelFunction;
   }
 
   if (!noteDeclaredName(name, kind, pos())) {
     return null();
   }
 
   FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Statement;
   FunctionNodeType funNode = handler.newFunction(syntaxKind, pos());
@@ -3371,55 +3374,55 @@ template <typename Unit>
 bool Parser<FullParseHandler, Unit>::asmJS(ListNodeType list) {
   // Disable syntax parsing in anything nested inside the asm.js module.
   disableSyntaxParser();
 
   // We should be encountering the "use asm" directive for the first time; if
   // the directive is already, we must have failed asm.js validation and we're
   // reparsing. In that case, don't try to validate again. A non-null
   // newDirectives means we're not in a normal function.
-  if (!pc->newDirectives || pc->newDirectives->asmJS()) {
+  if (!pc_->newDirectives || pc_->newDirectives->asmJS()) {
     return true;
   }
 
   // If there is no ScriptSource, then we are doing a non-compiling parse and
   // so we shouldn't (and can't, without a ScriptSource) compile.
   if (ss == nullptr) {
     return true;
   }
 
   ss->setContainsAsmJS();
-  pc->functionBox()->useAsm = true;
+  pc_->functionBox()->useAsm = true;
 
   // Attempt to validate and compile this asm.js module. On success, the
   // tokenStream has been advanced to the closing }. On failure, the
   // tokenStream is in an indeterminate state and we must reparse the
   // function from the beginning. Reparsing is triggered by marking that a
   // new directive has been encountered and returning 'false'.
   bool validated;
   if (!CompileAsmJS(cx_, *this, list, &validated)) {
     return false;
   }
   if (!validated) {
-    pc->newDirectives->setAsmJS();
+    pc_->newDirectives->setAsmJS();
     return false;
   }
 
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 inline bool GeneralParser<ParseHandler, Unit>::asmJS(ListNodeType list) {
   return asFinalParser()->asmJS(list);
 }
 
 /*
  * Recognize Directive Prologue members and directives. Assuming |pn| is a
  * candidate for membership in a directive prologue, recognize directives and
- * set |pc|'s flags accordingly. If |pn| is indeed part of a prologue, set its
+ * set |pc_|'s flags accordingly. If |pn| is indeed part of a prologue, set its
  * |prologue| flag.
  *
  * Note that the following is a strict mode function:
  *
  * function foo() {
  *   "blah" // inserted semi colon
  *        "blurgh"
  *   "use\x20loose"
@@ -3454,44 +3457,44 @@ bool GeneralParser<ParseHandler, Unit>::
     // taking advantage of directive-prologue-enabled features that appear
     // in other browsers first.
     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 (pc_->isFunctionBox()) {
+        FunctionBox* funbox = pc_->functionBox();
         if (!funbox->hasSimpleParameterList()) {
           const char* parameterKind =
               funbox->hasDestructuringArgs
                   ? "destructuring"
                   : funbox->hasParameterExprs ? "default" : "rest";
           errorAt(directivePos.begin, JSMSG_STRICT_NON_SIMPLE_PARAMS,
                   parameterKind);
           return false;
         }
       }
 
       // We're going to be in strict mode. Note that this scope explicitly
       // had "use strict";
-      pc->sc()->setExplicitUseStrict();
-      if (!pc->sc()->strict()) {
+      pc_->sc()->setExplicitUseStrict();
+      if (!pc_->sc()->strict()) {
         // We keep track of the one possible strict violation that could
         // occur in the directive prologue -- octal escapes -- and
         // complain now.
         if (anyChars.sawOctalEscape()) {
           error(JSMSG_DEPRECATED_OCTAL);
           return false;
         }
-        pc->sc()->strictScript = true;
+        pc_->sc()->strictScript = true;
       }
     } else if (directive == cx_->names().useAsm) {
-      if (pc->isFunctionBox()) {
+      if (pc_->isFunctionBox()) {
         return asmJS(list);
       }
       return warningAt(directivePos.begin, JSMSG_USE_ASM_DIRECTIVE_FAIL);
     }
   }
   return true;
 }
 
@@ -3502,17 +3505,17 @@ GeneralParser<ParseHandler, Unit>::state
     return null();
   }
 
   ListNodeType stmtList = handler.newStatementList(pos());
   if (!stmtList) {
     return null();
   }
 
-  bool canHaveDirectives = pc->atBodyLevel();
+  bool canHaveDirectives = pc_->atBodyLevel();
   if (canHaveDirectives) {
     anyChars.clearSawOctalEscape();
   }
   bool afterReturn = false;
   bool warnedAboutStatementsAfterReturn = false;
   uint32_t statementBegin = 0;
   for (;;) {
     TokenKind tt = TokenKind::Eof;
@@ -3760,17 +3763,17 @@ void GeneralParser<ParseHandler, Unit>::
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::bindingInitializer(
     Node lhs, DeclarationKind kind, YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Assign));
 
   if (kind == DeclarationKind::FormalParameter) {
-    pc->functionBox()->hasParameterExprs = true;
+    pc_->functionBox()->hasParameterExprs = true;
   }
 
   Node rhs = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (!rhs) {
     return null();
   }
 
   BinaryNodeType assign =
@@ -4090,42 +4093,42 @@ GeneralParser<ParseHandler, Unit>::destr
              ? arrayBindingPattern(kind, yieldHandling)
              : objectBindingPattern(kind, yieldHandling);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::destructuringDeclarationWithoutYieldOrAwait(
     DeclarationKind kind, YieldHandling yieldHandling, TokenKind tt) {
-  uint32_t startYieldOffset = pc->lastYieldOffset;
-  uint32_t startAwaitOffset = pc->lastAwaitOffset;
+  uint32_t startYieldOffset = pc_->lastYieldOffset;
+  uint32_t startAwaitOffset = pc_->lastAwaitOffset;
   Node res = destructuringDeclaration(kind, yieldHandling, tt);
   if (res) {
-    if (pc->lastYieldOffset != startYieldOffset) {
-      errorAt(pc->lastYieldOffset, JSMSG_YIELD_IN_PARAMETER);
-      return null();
-    }
-    if (pc->lastAwaitOffset != startAwaitOffset) {
-      errorAt(pc->lastAwaitOffset, JSMSG_AWAIT_IN_PARAMETER);
+    if (pc_->lastYieldOffset != startYieldOffset) {
+      errorAt(pc_->lastYieldOffset, JSMSG_YIELD_IN_PARAMETER);
+      return null();
+    }
+    if (pc_->lastAwaitOffset != startAwaitOffset) {
+      errorAt(pc_->lastAwaitOffset, JSMSG_AWAIT_IN_PARAMETER);
       return null();
     }
   }
   return res;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::LexicalScopeNodeType
 GeneralParser<ParseHandler, Unit>::blockStatement(YieldHandling yieldHandling,
                                                   unsigned errorNumber) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftCurly));
   uint32_t openedPos = pos().begin;
 
-  ParseContext::Statement stmt(pc, StatementKind::Block);
+  ParseContext::Statement stmt(pc_, StatementKind::Block);
   ParseContext::Scope scope(this);
-  if (!scope.init(pc)) {
+  if (!scope.init(pc_)) {
     return null();
   }
 
   ListNodeType list = statementList(yieldHandling);
   if (!list) {
     return null();
   }
 
@@ -4570,17 +4573,17 @@ bool Parser<FullParseHandler, Unit>::nam
       return false;
     }
     if (!noteDeclaredName(bindingName, DeclarationKind::Const, pos())) {
       return false;
     }
 
     // The namespace import name is currently required to live on the
     // environment.
-    pc->varScope().lookupDeclaredName(bindingName)->value()->setClosedOver();
+    pc_->varScope().lookupDeclaredName(bindingName)->value()->setClosedOver();
 
     BinaryNodeType importSpec =
         handler.newImportSpec(importName, bindingNameNode);
     if (!importSpec) {
       return false;
     }
 
     handler.addList(importSpecSet, importSpec);
@@ -4588,17 +4591,17 @@ bool Parser<FullParseHandler, Unit>::nam
 
   return true;
 }
 
 template <typename Unit>
 BinaryNode* Parser<FullParseHandler, Unit>::importDeclaration() {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Import));
 
-  if (!pc->atModuleLevel()) {
+  if (!pc_->atModuleLevel()) {
     error(JSMSG_IMPORT_DECL_AT_TOP_LEVEL);
     return null();
   }
 
   uint32_t begin = pos().begin;
   TokenKind tt;
   if (!tokenStream.getToken(&tt)) {
     return null();
@@ -4690,17 +4693,17 @@ BinaryNode* Parser<FullParseHandler, Uni
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
 
   BinaryNode* node = handler.newImportDeclaration(importSpecSet, moduleSpec,
                                                   TokenPos(begin, pos().end));
-  if (!node || !pc->sc()->asModuleContext()->builder.processImport(node)) {
+  if (!node || !pc_->sc()->asModuleContext()->builder.processImport(node)) {
     return null();
   }
 
   return node;
 }
 
 template <typename Unit>
 inline SyntaxParseHandler::BinaryNodeType
@@ -4730,17 +4733,17 @@ GeneralParser<ParseHandler, Unit>::impor
     return expressionStatement(yieldHandling);
   }
 
   return importDeclaration();
 }
 
 template <typename Unit>
 bool Parser<FullParseHandler, Unit>::checkExportedName(JSAtom* exportName) {
-  if (!pc->sc()->asModuleContext()->builder.hasExportedName(exportName)) {
+  if (!pc_->sc()->asModuleContext()->builder.hasExportedName(exportName)) {
     return true;
   }
 
   UniqueChars str = AtomToPrintableString(cx_, exportName);
   if (!str) {
     return false;
   }
 
@@ -4972,29 +4975,29 @@ inline bool Parser<SyntaxParseHandler, U
 template <class ParseHandler, typename Unit>
 inline bool GeneralParser<ParseHandler, Unit>::checkExportedNameForClass(
     ClassNodeType classNode) {
   return asFinalParser()->checkExportedNameForClass(classNode);
 }
 
 template <>
 inline bool PerHandlerParser<FullParseHandler>::processExport(ParseNode* node) {
-  return pc->sc()->asModuleContext()->builder.processExport(node);
+  return pc_->sc()->asModuleContext()->builder.processExport(node);
 }
 
 template <>
 inline bool PerHandlerParser<SyntaxParseHandler>::processExport(Node node) {
   MOZ_ALWAYS_FALSE(abortIfSyntaxParser());
   return false;
 }
 
 template <>
 inline bool PerHandlerParser<FullParseHandler>::processExportFrom(
     BinaryNodeType node) {
-  return pc->sc()->asModuleContext()->builder.processExportFrom(node);
+  return pc_->sc()->asModuleContext()->builder.processExportFrom(node);
 }
 
 template <>
 inline bool PerHandlerParser<SyntaxParseHandler>::processExportFrom(
     BinaryNodeType node) {
   MOZ_ALWAYS_FALSE(abortIfSyntaxParser());
   return false;
 }
@@ -5502,17 +5505,17 @@ template <class ParseHandler, typename U
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::exportDeclaration() {
   if (!abortIfSyntaxParser()) {
     return null();
   }
 
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Export));
 
-  if (!pc->atModuleLevel()) {
+  if (!pc_->atModuleLevel()) {
     error(JSMSG_EXPORT_DECL_AT_TOP_LEVEL);
     return null();
   }
 
   uint32_t begin = pos().begin;
 
   TokenKind tt;
   if (!tokenStream.getToken(&tt)) {
@@ -5597,34 +5600,34 @@ GeneralParser<ParseHandler, Unit>::conse
   //
   // Careful!  FunctionDeclaration doesn't include generators or async
   // functions.
   if (next == TokenKind::Function) {
     tokenStream.consumeKnownToken(next, TokenStream::Operand);
 
     // Parser::statement would handle this, but as this function handles
     // every other error case, it seems best to handle this.
-    if (pc->sc()->strict()) {
+    if (pc_->sc()->strict()) {
       error(JSMSG_FORBIDDEN_AS_STATEMENT, "function declarations");
       return null();
     }
 
     TokenKind maybeStar;
     if (!tokenStream.peekToken(&maybeStar)) {
       return null();
     }
 
     if (maybeStar == TokenKind::Mul) {
       error(JSMSG_FORBIDDEN_AS_STATEMENT, "generator declarations");
       return null();
     }
 
-    ParseContext::Statement stmt(pc, StatementKind::Block);
+    ParseContext::Statement stmt(pc_, StatementKind::Block);
     ParseContext::Scope scope(this);
-    if (!scope.init(pc)) {
+    if (!scope.init(pc_)) {
       return null();
     }
 
     TokenPos funcPos = pos();
     Node fun = functionStmt(pos().begin, yieldHandling, NameRequired);
     if (!fun) {
       return null();
     }
@@ -5643,17 +5646,17 @@ GeneralParser<ParseHandler, Unit>::conse
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::TernaryNodeType
 GeneralParser<ParseHandler, Unit>::ifStatement(YieldHandling yieldHandling) {
   Vector<Node, 4> condList(cx_), thenList(cx_);
   Vector<uint32_t, 4> posList(cx_);
   Node elseBranch;
 
-  ParseContext::Statement stmt(pc, StatementKind::If);
+  ParseContext::Statement stmt(pc_, StatementKind::If);
 
   while (true) {
     uint32_t begin = pos().begin;
 
     /* An IF node has three kids: condition, then, and optional else. */
     Node cond = condition(InAllowed, yieldHandling);
     if (!cond) {
       return null();
@@ -5715,17 +5718,17 @@ GeneralParser<ParseHandler, Unit>::ifSta
   return ifNode;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BinaryNodeType
 GeneralParser<ParseHandler, Unit>::doWhileStatement(
     YieldHandling yieldHandling) {
   uint32_t begin = pos().begin;
-  ParseContext::Statement stmt(pc, StatementKind::DoLoop);
+  ParseContext::Statement stmt(pc_, StatementKind::DoLoop);
   Node body = statement(yieldHandling);
   if (!body) {
     return null();
   }
   if (!mustMatchToken(TokenKind::While, TokenStream::Operand,
                       JSMSG_WHILE_AFTER_DO)) {
     return null();
   }
@@ -5747,17 +5750,17 @@ GeneralParser<ParseHandler, Unit>::doWhi
   }
   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);
+  ParseContext::Statement stmt(pc_, StatementKind::WhileLoop);
   Node cond = condition(InAllowed, yieldHandling);
   if (!cond) {
     return null();
   }
   Node body = statement(yieldHandling);
   if (!body) {
     return null();
   }
@@ -5840,24 +5843,24 @@ bool GeneralParser<ParseHandler, Unit>::
     if (!parsingLexicalDeclaration) {
       anyChars.ungetToken();
       letIsIdentifier = true;
     }
   }
 
   if (parsingLexicalDeclaration) {
     forLoopLexicalScope.emplace(this);
-    if (!forLoopLexicalScope->init(pc)) {
+    if (!forLoopLexicalScope->init(pc_)) {
       return false;
     }
 
     // Push a temporary ForLoopLexicalHead Statement that allows for
     // lexical declarations, as they are usually allowed only in braced
     // statements.
-    ParseContext::Statement forHeadStmt(pc, StatementKind::ForLoopLexicalHead);
+    ParseContext::Statement forHeadStmt(pc_, StatementKind::ForLoopLexicalHead);
 
     *forInitialPart =
         declarationList(yieldHandling,
                         tt == TokenKind::Const ? ParseNodeKind::ConstDecl
                                                : ParseNodeKind::LetDecl,
                         forHeadKind, forInOrOfExpression);
     return *forInitialPart != null();
   }
@@ -5949,35 +5952,35 @@ bool GeneralParser<ParseHandler, Unit>::
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::forStatement(
     YieldHandling yieldHandling) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::For));
 
   uint32_t begin = pos().begin;
 
-  ParseContext::Statement stmt(pc, StatementKind::ForLoop);
+  ParseContext::Statement stmt(pc_, StatementKind::ForLoop);
 
   IteratorKind iterKind = IteratorKind::Sync;
   unsigned iflags = 0;
 
-  if (pc->isAsync()) {
+  if (pc_->isAsync()) {
     bool matched;
     if (!tokenStream.matchToken(&matched, TokenKind::Await)) {
       return null();
     }
 
     if (matched) {
       iflags |= JSITER_FORAWAITOF;
       iterKind = IteratorKind::Async;
     }
   }
 
   if (!mustMatchToken(TokenKind::LeftParen, [this](TokenKind actual) {
-        this->error((actual == TokenKind::Await && !this->pc->isAsync())
+        this->error((actual == TokenKind::Await && !this->pc_->isAsync())
                         ? JSMSG_FOR_AWAIT_OUTSIDE_ASYNC
                         : JSMSG_PAREN_AFTER_FOR);
       })) {
     return null();
   }
 
   // ParseNodeKind::ForHead, ParseNodeKind::ForIn, or
   // ParseNodeKind::ForOf depending on the loop type.
@@ -6152,19 +6155,19 @@ GeneralParser<ParseHandler, Unit>::switc
   if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                       JSMSG_PAREN_AFTER_SWITCH)) {
     return null();
   }
   if (!mustMatchToken(TokenKind::LeftCurly, JSMSG_CURLY_BEFORE_SWITCH)) {
     return null();
   }
 
-  ParseContext::Statement stmt(pc, StatementKind::Switch);
+  ParseContext::Statement stmt(pc_, StatementKind::Switch);
   ParseContext::Scope scope(this);
-  if (!scope.init(pc)) {
+  if (!scope.init(pc_)) {
     return null();
   }
 
   ListNodeType caseList = handler.newStatementList(pos());
   if (!caseList) {
     return null();
   }
 
@@ -6274,17 +6277,17 @@ GeneralParser<ParseHandler, Unit>::conti
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Continue));
   uint32_t begin = pos().begin;
 
   RootedPropertyName label(cx_);
   if (!matchLabel(yieldHandling, &label)) {
     return null();
   }
 
-  auto validity = pc->checkContinueStatement(label);
+  auto validity = pc_->checkContinueStatement(label);
   if (validity.isErr()) {
     switch (validity.unwrapErr()) {
       case ParseContext::ContinueStatementError::NotInALoop:
         errorAt(begin, JSMSG_BAD_CONTINUE);
         break;
       case ParseContext::ContinueStatementError::LabelNotFound:
         error(JSMSG_LABEL_NOT_FOUND);
         break;
@@ -6313,27 +6316,27 @@ GeneralParser<ParseHandler, Unit>::break
   // Labeled 'break' statements target the nearest labeled statements (could
   // be any kind) with the same label. Unlabeled 'break' statements target
   // the innermost loop or switch statement.
   if (label) {
     auto hasSameLabel = [&label](ParseContext::LabelStatement* stmt) {
       return stmt->label() == label;
     };
 
-    if (!pc->template findInnermostStatement<ParseContext::LabelStatement>(
+    if (!pc_->template findInnermostStatement<ParseContext::LabelStatement>(
             hasSameLabel)) {
       error(JSMSG_LABEL_NOT_FOUND);
       return null();
     }
   } else {
     auto isBreakTarget = [](ParseContext::Statement* stmt) {
       return StatementKindIsUnlabeledBreakTarget(stmt->kind());
     };
 
-    if (!pc->findInnermostStatement(isBreakTarget)) {
+    if (!pc_->findInnermostStatement(isBreakTarget)) {
       errorAt(begin, JSMSG_TOUGH_BREAK);
       return null();
     }
   }
 
   if (!matchOrInsertSemicolon()) {
     return null();
   }
@@ -6343,18 +6346,18 @@ GeneralParser<ParseHandler, Unit>::break
 
 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;
 
-  MOZ_ASSERT(pc->isFunctionBox());
-  pc->functionBox()->usesReturn = true;
+  MOZ_ASSERT(pc_->isFunctionBox());
+  pc_->functionBox()->usesReturn = true;
 
   // Parse an optional operand.
   //
   // This is ugly, but we don't want to require a semicolon.
   Node exprNode;
   TokenKind tt = TokenKind::Eof;
   if (!tokenStream.peekTokenSameLine(&tt, TokenStream::Operand)) {
     return null();
@@ -6382,20 +6385,20 @@ GeneralParser<ParseHandler, Unit>::retur
 }
 
 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;
 
-  MOZ_ASSERT(pc->isGenerator());
-  MOZ_ASSERT(pc->isFunctionBox());
-
-  pc->lastYieldOffset = begin;
+  MOZ_ASSERT(pc_->isGenerator());
+  MOZ_ASSERT(pc_->isFunctionBox());
+
+  pc_->lastYieldOffset = begin;
 
   Node exprNode;
   ParseNodeKind kind = ParseNodeKind::YieldExpr;
   TokenKind tt = TokenKind::Eof;
   if (!tokenStream.peekTokenSameLine(&tt, TokenStream::Operand)) {
     return null();
   }
   switch (tt) {
@@ -6440,17 +6443,17 @@ GeneralParser<ParseHandler, Unit>::withS
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::With));
   uint32_t begin = pos().begin;
 
   // Usually we want the constructs forbidden in strict mode code to be a
   // subset of those that ContextOptions::extraWarnings() warns about, and we
   // use strictModeError directly.  But while 'with' is forbidden in strict
   // mode code, it doesn't even merit a warning in non-strict code.  See
   // https://bugzilla.mozilla.org/show_bug.cgi?id=514576#c1.
-  if (pc->sc()->strict()) {
+  if (pc_->sc()->strict()) {
     if (!strictModeError(JSMSG_STRICT_CODE_WITH)) {
       return null();
     }
   }
 
   if (!mustMatchToken(TokenKind::LeftParen, JSMSG_PAREN_BEFORE_WITH)) {
     return null();
   }
@@ -6462,24 +6465,24 @@ GeneralParser<ParseHandler, Unit>::withS
 
   if (!mustMatchToken(TokenKind::RightParen, TokenStream::Operand,
                       JSMSG_PAREN_AFTER_WITH)) {
     return null();
   }
 
   Node innerBlock;
   {
-    ParseContext::Statement stmt(pc, StatementKind::With);
+    ParseContext::Statement stmt(pc_, StatementKind::With);
     innerBlock = statement(yieldHandling);
     if (!innerBlock) {
       return null();
     }
   }
 
-  pc->sc()->setBindingsAccessedDynamically();
+  pc_->sc()->setBindingsAccessedDynamically();
 
   return handler.newWithStatement(begin, objectExpr, innerBlock);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::labeledItem(
     YieldHandling yieldHandling) {
   TokenKind tt;
@@ -6498,17 +6501,17 @@ typename ParseHandler::Node GeneralParse
     if (next == TokenKind::Mul) {
       error(JSMSG_GENERATOR_LABEL);
       return null();
     }
 
     // Per 13.13.1 it's a syntax error if LabelledItem: FunctionDeclaration
     // is ever matched.  Per Annex B.3.2 that modifies this text, this
     // applies only to strict mode code.
-    if (pc->sc()->strict()) {
+    if (pc_->sc()->strict()) {
       error(JSMSG_FUNCTION_LABEL);
       return null();
     }
 
     return functionStmt(pos().begin, yieldHandling, NameRequired);
   }
 
   anyChars.ungetToken();
@@ -6525,26 +6528,26 @@ GeneralParser<ParseHandler, Unit>::label
   }
 
   auto hasSameLabel = [&label](ParseContext::LabelStatement* stmt) {
     return stmt->label() == label;
   };
 
   uint32_t begin = pos().begin;
 
-  if (pc->template findInnermostStatement<ParseContext::LabelStatement>(
+  if (pc_->template findInnermostStatement<ParseContext::LabelStatement>(
           hasSameLabel)) {
     errorAt(begin, JSMSG_DUPLICATE_LABEL);
     return null();
   }
 
   tokenStream.consumeKnownToken(TokenKind::Colon);
 
   /* Push a label struct and parse the statement. */
-  ParseContext::LabelStatement stmt(pc, label);
+  ParseContext::LabelStatement stmt(pc_, label);
   Node pn = labeledItem(yieldHandling);
   if (!pn) {
     return null();
   }
 
   return handler.newLabeledStatement(label, pn, begin);
 }
 
@@ -6608,19 +6611,19 @@ GeneralParser<ParseHandler, Unit>::trySt
   Node innerBlock;
   {
     if (!mustMatchToken(TokenKind::LeftCurly, JSMSG_CURLY_BEFORE_TRY)) {
       return null();
     }
 
     uint32_t openedPos = pos().begin;
 
-    ParseContext::Statement stmt(pc, StatementKind::Try);
+    ParseContext::Statement stmt(pc_, StatementKind::Try);
     ParseContext::Scope scope(this);
-    if (!scope.init(pc)) {
+    if (!scope.init(pc_)) {
       return null();
     }
 
     innerBlock = statementList(yieldHandling);
     if (!innerBlock) {
       return null();
     }
 
@@ -6644,19 +6647,19 @@ GeneralParser<ParseHandler, Unit>::trySt
   if (!tokenStream.getToken(&tt)) {
     return null();
   }
   if (tt == TokenKind::Catch) {
     /*
      * Create a lexical scope node around the whole catch clause,
      * including the head.
      */
-    ParseContext::Statement stmt(pc, StatementKind::Catch);
+    ParseContext::Statement stmt(pc_, StatementKind::Catch);
     ParseContext::Scope scope(this);
-    if (!scope.init(pc)) {
+    if (!scope.init(pc_)) {
       return null();
     }
 
     /*
      * Legal catch forms are:
      *   catch (lhs) {
      *   catch {
      * where lhs is a name or a destructuring left-hand side.
@@ -6736,19 +6739,19 @@ GeneralParser<ParseHandler, Unit>::trySt
 
   if (tt == TokenKind::Finally) {
     if (!mustMatchToken(TokenKind::LeftCurly, JSMSG_CURLY_BEFORE_FINALLY)) {
       return null();
     }
 
     uint32_t openedPos = pos().begin;
 
-    ParseContext::Statement stmt(pc, StatementKind::Finally);
+    ParseContext::Statement stmt(pc_, StatementKind::Finally);
     ParseContext::Scope scope(this);
-    if (!scope.init(pc)) {
+    if (!scope.init(pc_)) {
       return null();
     }
 
     finallyBlock = statementList(yieldHandling);
     if (!finallyBlock) {
       return null();
     }
 
@@ -6777,30 +6780,30 @@ GeneralParser<ParseHandler, Unit>::trySt
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::LexicalScopeNodeType
 GeneralParser<ParseHandler, Unit>::catchBlockStatement(
     YieldHandling yieldHandling, ParseContext::Scope& catchParamScope) {
   uint32_t openedPos = pos().begin;
 
-  ParseContext::Statement stmt(pc, StatementKind::Block);
+  ParseContext::Statement stmt(pc_, StatementKind::Block);
 
   // ES 13.15.7 CatchClauseEvaluation
   //
   // Step 8 means that the body of a catch block always has an additional
   // lexical scope.
   ParseContext::Scope scope(this);
-  if (!scope.init(pc)) {
+  if (!scope.init(pc_)) {
     return null();
   }
 
   // The catch parameter names cannot be redeclared inside the catch
   // block, so declare the name in the inner scope.
-  if (!scope.addCatchParameters(pc, catchParamScope)) {
+  if (!scope.addCatchParameters(pc_, catchParamScope)) {
     return null();
   }
 
   ListNodeType list = statementList(yieldHandling);
   if (!list) {
     return null();
   }
 
@@ -6810,32 +6813,32 @@ GeneralParser<ParseHandler, Unit>::catch
                                                    JSMSG_CURLY_OPENED,
                                                    openedPos);
                       })) {
     return null();
   }
 
   // The catch parameter names are not bound in the body scope, so remove
   // them before generating bindings.
-  scope.removeCatchParameters(pc, catchParamScope);
+  scope.removeCatchParameters(pc_, catchParamScope);
   return finishLexicalScope(scope, list);
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::DebuggerStatementType
 GeneralParser<ParseHandler, Unit>::debuggerStatement() {
   TokenPos p;
   p.begin = pos().begin;
   if (!matchOrInsertSemicolon()) {
     return null();
   }
   p.end = pos().end;
 
-  pc->sc()->setBindingsAccessedDynamically();
-  pc->sc()->setHasDebuggerStatement();
+  pc_->sc()->setBindingsAccessedDynamically();
+  pc_->sc()->setHasDebuggerStatement();
 
   return handler.newDebuggerStatement(p);
 }
 
 static AccessorType ToAccessorType(PropertyType propType) {
   switch (propType) {
     case PropertyType::Getter:
       return AccessorType::Getter;
@@ -6886,28 +6889,28 @@ GeneralParser<ParseHandler, Unit>::class
     }
   } else {
     // Make sure to put it back, whatever it was
     anyChars.ungetToken();
   }
 
   // Push a ParseContext::ClassStatement to keep track of the constructor
   // funbox.
-  ParseContext::ClassStatement classStmt(pc);
+  ParseContext::ClassStatement classStmt(pc_);
 
   RootedAtom propAtom(cx_);
 
   // A named class creates a new lexical scope with a const binding of the
   // class name for the "inner name".
   Maybe<ParseContext::Statement> innerScopeStmt;
   Maybe<ParseContext::Scope> innerScope;
   if (className) {
-    innerScopeStmt.emplace(pc, StatementKind::Block);
+    innerScopeStmt.emplace(pc_, StatementKind::Block);
     innerScope.emplace(this);
-    if (!innerScope->init(pc)) {
+    if (!innerScope->init(pc_)) {
       return null();
     }
   }
 
   // Because the binding definitions keep track of their blockId, we need to
   // create at least the inner binding later. Keep track of the name's position
   // in order to provide it for the nodes created later.
   TokenPos namePos = pos();
@@ -7213,17 +7216,17 @@ GeneralParser<ParseHandler, Unit>::synth
   // 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);
+  funbox->initWithEnclosingParseContext(pc_, functionSyntaxKind);
   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();
   }
@@ -7236,17 +7239,17 @@ GeneralParser<ParseHandler, Unit>::synth
     return null();
   }
   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)) {
+  if (!lexicalScope.init(pc_)) {
     return null();
   }
 
   auto stmtList = handler.newStatementList(synthesizedBodyPos);
   if (!stmtList) {
     return null();
   }
 
@@ -7304,34 +7307,34 @@ GeneralParser<ParseHandler, Unit>::field
   // 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);
+  funbox->initWithEnclosingParseContext(pc_, FunctionSyntaxKind::Expression);
   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
   ParseContext::VarScope varScope(this);
-  if (!varScope.init(pc)) {
+  if (!varScope.init(pc_)) {
     return null();
   }
 
   // push a LexicalScope on to the stack
   ParseContext::Scope lexicalScope(this);
-  if (!lexicalScope.init(pc)) {
+  if (!lexicalScope.init(pc_)) {
     return null();
   }
 
   // Create a ListNode for the parameters + body (there are no parameters)
   ListNodeType argsbody = handler.newList(ParseNodeKind::ParamsBody, fieldPos);
   if (!argsbody) {
     return null();
   }
@@ -7495,17 +7498,17 @@ typename ParseHandler::Node GeneralParse
         return labeledStatement(yieldHandling);
       }
 
       return expressionStatement(yieldHandling);
     }
 
     default: {
       // Avoid getting next token with None.
-      if (tt == TokenKind::Await && pc->isAsync()) {
+      if (tt == TokenKind::Await && pc_->isAsync()) {
         return expressionStatement(yieldHandling);
       }
 
       if (!TokenKindIsPossibleIdentifier(tt)) {
         return expressionStatement(yieldHandling);
       }
 
       TokenKind next;
@@ -7615,17 +7618,17 @@ typename ParseHandler::Node GeneralParse
     case TokenKind::Break:
       return breakStatement(yieldHandling);
 
     // [+Return] ReturnStatement[?Yield]
     case TokenKind::Return:
       // The Return parameter is only used here, and the effect is easily
       // detected this way, so don't bother passing around an extra parameter
       // everywhere.
-      if (!pc->isFunctionBox()) {
+      if (!pc_->isFunctionBox()) {
         error(JSMSG_BAD_RETURN_OR_YIELD, js_return_str);
         return null();
       }
       return returnStatement(yieldHandling);
 
     // WithStatement[?Yield, ?Return]
     case TokenKind::With:
       return withStatement(yieldHandling);
@@ -7742,17 +7745,17 @@ GeneralParser<ParseHandler, Unit>::state
         return labeledStatement(yieldHandling);
       }
 
       return expressionStatement(yieldHandling);
     }
 
     default: {
       // Avoid getting next token with None.
-      if (tt == TokenKind::Await && pc->isAsync()) {
+      if (tt == TokenKind::Await && pc_->isAsync()) {
         return expressionStatement(yieldHandling);
       }
 
       if (!TokenKindIsPossibleIdentifier(tt)) {
         return expressionStatement(yieldHandling);
       }
 
       TokenKind next;
@@ -7816,17 +7819,17 @@ GeneralParser<ParseHandler, Unit>::state
     case TokenKind::Break:
       return breakStatement(yieldHandling);
 
     // [+Return] ReturnStatement[?Yield]
     case TokenKind::Return:
       // The Return parameter is only used here, and the effect is easily
       // detected this way, so don't bother passing around an extra parameter
       // everywhere.
-      if (!pc->isFunctionBox()) {
+      if (!pc_->isFunctionBox()) {
         error(JSMSG_BAD_RETURN_OR_YIELD, js_return_str);
         return null();
       }
       return returnStatement(yieldHandling);
 
     // WithStatement[?Yield, ?Return]
     case TokenKind::With:
       return withStatement(yieldHandling);
@@ -8078,17 +8081,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;
     }
@@ -8433,17 +8436,17 @@ 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 (!pc->sc()->strict()) {
+    if (!pc_->sc()->strict()) {
       return true;
     }
 
     return !nameIsArgumentsOrEval(node);
   }
 
   if (handler.isPropertyAccess(node)) {
     return true;
@@ -8591,34 +8594,34 @@ typename ParseHandler::Node GeneralParse
 
       // 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 (!strictModeErrorAt(exprOffset, JSMSG_DEPRECATED_DELETE_OPERAND)) {
           return null();
         }
 
-        pc->sc()->setBindingsAccessedDynamically();
+        pc_->sc()->setBindingsAccessedDynamically();
       }
 
       return handler.newDelete(begin, expr);
     }
 
     case TokenKind::Await: {
-      if (pc->isAsync()) {
+      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;
+        pc_->lastAwaitOffset = begin;
         return handler.newAwaitExpression(begin, kid);
       }
     }
 
       MOZ_FALLTHROUGH;
 
     default: {
       Node expr =
@@ -8649,26 +8652,26 @@ typename ParseHandler::Node GeneralParse
     }
   }
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, Unit>::assignExprWithoutYieldOrAwait(
     YieldHandling yieldHandling) {
-  uint32_t startYieldOffset = pc->lastYieldOffset;
-  uint32_t startAwaitOffset = pc->lastAwaitOffset;
+  uint32_t startYieldOffset = pc_->lastYieldOffset;
+  uint32_t startAwaitOffset = pc_->lastAwaitOffset;
   Node res = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (res) {
-    if (pc->lastYieldOffset != startYieldOffset) {
-      errorAt(pc->lastYieldOffset, JSMSG_YIELD_IN_PARAMETER);
-      return null();
-    }
-    if (pc->lastAwaitOffset != startAwaitOffset) {
-      errorAt(pc->lastAwaitOffset, JSMSG_AWAIT_IN_PARAMETER);
+    if (pc_->lastYieldOffset != startYieldOffset) {
+      errorAt(pc_->lastYieldOffset, JSMSG_YIELD_IN_PARAMETER);
+      return null();
+    }
+    if (pc_->lastAwaitOffset != startAwaitOffset) {
+      errorAt(pc_->lastAwaitOffset, JSMSG_AWAIT_IN_PARAMETER);
       return null();
     }
   }
   return res;
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::ListNodeType
@@ -8740,21 +8743,21 @@ GeneralParser<ParseHandler, Unit>::argum
     return null();
   }
 
   handler.setEndPosition(argsList, pos().end);
   return argsList;
 }
 
 bool ParserBase::checkAndMarkSuperScope() {
-  if (!pc->sc()->allowSuperProperty()) {
+  if (!pc_->sc()->allowSuperProperty()) {
     return false;
   }
 
-  pc->setSuperScopeNeedsHomeObject();
+  pc_->setSuperScopeNeedsHomeObject();
   return true;
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::computeErrorMetadata(
     ErrorMetadata* err, const ErrorReportMixin::ErrorOffset& offset) {
   if (offset.is<ErrorReportMixin::Current>()) {
     return tokenStream.computeErrorMetadata(err, AsVariant(pos().begin));
@@ -8899,17 +8902,17 @@ typename ParseHandler::Node GeneralParse
       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 (!pc->sc()->allowSuperCall()) {
+        if (!pc_->sc()->allowSuperCall()) {
           error(JSMSG_BAD_SUPERCALL);
           return null();
         }
 
         if (tt != TokenKind::LeftParen) {
           error(JSMSG_BAD_SUPER);
           return null();
         }
@@ -8949,42 +8952,42 @@ typename ParseHandler::Node GeneralParse
 
         JSOp op = JSOP_CALL;
         bool maybeAsyncArrow = false;
         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;
+            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_)) {
             // |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_)) {
-            // Select the right EVAL op and flag pc as having a
+            // 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();
+            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.
-            if (pc->isFunctionBox() && !pc->sc()->strict()) {
-              pc->functionBox()->setHasExtensibleScope();
+            if (pc_->isFunctionBox() && !pc_->sc()->strict()) {
+              pc_->functionBox()->setHasExtensibleScope();
             }
 
             // If we're in a method, mark the method as requiring
             // support for 'super', since direct eval code can use
             // it. (If we're not in a method, that's fine, so
             // ignore the return value.)
             checkAndMarkSuperScope();
           }
@@ -9078,48 +9081,48 @@ bool GeneralParser<ParseHandler, Unit>::
     return true;
   }
   if (TokenKindIsContextualKeyword(tt)) {
     if (tt == TokenKind::Yield) {
       if (yieldHandling == YieldIsKeyword) {
         errorAt(offset, JSMSG_RESERVED_ID, "yield");
         return false;
       }
-      if (pc->sc()->needStrictChecks()) {
+      if (pc_->sc()->needStrictChecks()) {
         if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "yield")) {
           return false;
         }
       }
       return true;
     }
     if (tt == TokenKind::Await) {
       if (awaitIsKeyword()) {
         errorAt(offset, JSMSG_RESERVED_ID, "await");
         return false;
       }
       return true;
     }
-    if (pc->sc()->needStrictChecks()) {
+    if (pc_->sc()->needStrictChecks()) {
       if (tt == TokenKind::Let) {
         if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "let")) {
           return false;
         }
         return true;
       }
       if (tt == TokenKind::Static) {
         if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID, "static")) {
           return false;
         }
         return true;
       }
     }
     return true;
   }
   if (TokenKindIsStrictReservedWord(tt)) {
-    if (pc->sc()->needStrictChecks()) {
+    if (pc_->sc()->needStrictChecks()) {
       if (!strictModeErrorAt(offset, JSMSG_RESERVED_ID,
                              ReservedWordToCharZ(tt))) {
         return false;
       }
     }
     return true;
   }
   if (TokenKindIsKeyword(tt) || TokenKindIsReservedWordLiteral(tt)) {
@@ -9133,17 +9136,17 @@ bool GeneralParser<ParseHandler, Unit>::
   MOZ_ASSERT_UNREACHABLE("Unexpected reserved word kind.");
   return false;
 }
 
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::checkBindingIdentifier(
     PropertyName* ident, uint32_t offset, YieldHandling yieldHandling,
     TokenKind hint /* = TokenKind::Limit */) {
-  if (pc->sc()->needStrictChecks()) {
+  if (pc_->sc()->needStrictChecks()) {
     if (ident == cx_->names().arguments) {
       if (!strictModeErrorAt(offset, JSMSG_BAD_STRICT_ASSIGN, "arguments")) {
         return false;
       }
       return true;
     }
 
     if (ident == cx_->names().eval) {
@@ -9380,30 +9383,30 @@ void GeneralParser<ParseHandler, Unit>::
   MOZ_ASSERT(isName);
 #endif
 
   // Return early if a pending destructuring error is already present.
   if (possibleError->hasPendingDestructuringError()) {
     return;
   }
 
-  if (pc->sc()->needStrictChecks()) {
+  if (pc_->sc()->needStrictChecks()) {
     if (handler.isArgumentsName(name, cx_)) {
-      if (pc->sc()->strict()) {
+      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 (pc->sc()->strict()) {
+      if (pc_->sc()->strict()) {
         possibleError->setPendingDestructuringErrorAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_EVAL);
       } else {
         possibleError->setPendingDestructuringWarningAt(
             namePos, JSMSG_BAD_STRICT_ASSIGN_EVAL);
       }
       return;
     }
@@ -9790,17 +9793,17 @@ GeneralParser<ParseHandler, Unit>::compu
     YieldHandling yieldHandling, const Maybe<DeclarationKind>& maybeDecl,
     PropertyNameContext propertyNameContext, ListNodeType literal) {
   MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::LeftBracket));
 
   uint32_t begin = pos().begin;
 
   if (maybeDecl) {
     if (*maybeDecl == DeclarationKind::FormalParameter) {
-      pc->functionBox()->hasParameterExprs = true;
+      pc_->functionBox()->hasParameterExprs = true;
     }
   } else if (propertyNameContext ==
              PropertyNameContext::PropertyNameInLiteral) {
     handler.setListHasNonConstInitializer(literal);
   }
 
   Node assignNode = assignExpr(InAllowed, yieldHandling, TripledotProhibited);
   if (!assignNode) {
@@ -10156,17 +10159,17 @@ bool GeneralParser<ParseHandler, Unit>::
   if (!tokenStream.getToken(&next)) {
     return false;
   }
   if (next != TokenKind::Target) {
     error(JSMSG_UNEXPECTED_TOKEN, "target", TokenKindToDesc(next));
     return false;
   }
 
-  if (!pc->sc()->allowNewTarget()) {
+  if (!pc_->sc()->allowNewTarget()) {
     errorAt(begin, JSMSG_BAD_NEWTARGET);
     return false;
   }
 
   NullaryNodeType targetHolder = handler.newPosHolder(pos());
   if (!targetHolder) {
     return false;
   }
@@ -10344,21 +10347,21 @@ typename ParseHandler::Node GeneralParse
     case TokenKind::BigInt:
       return newBigInt();
 
     case TokenKind::True:
       return handler.newBooleanLiteral(true, pos());
     case TokenKind::False:
       return handler.newBooleanLiteral(false, pos());
     case TokenKind::This: {
-      if (pc->isFunctionBox()) {
-        pc->functionBox()->usesThis = true;
+      if (pc_->isFunctionBox()) {
+        pc_->functionBox()->usesThis = true;
       }
       NameNodeType thisName = null();
-      if (pc->sc()->thisBinding() == ThisBinding::Function) {
+      if (pc_->sc()->thisBinding() == ThisBinding::Function) {
         thisName = newThisName();
         if (!thisName) {
           return null();
         }
       }
       return handler.newThisLiteral(pos(), thisName);
     }
     case TokenKind::Null:
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -196,17 +196,17 @@ class ParserBase;
 template <class ParseHandler, typename Unit>
 class GeneralParser;
 
 class SourceParseContext : public ParseContext {
  public:
   template <typename ParseHandler, typename Unit>
   SourceParseContext(GeneralParser<ParseHandler, Unit>* prs, SharedContext* sc,
                      Directives* newDirectives)
-      : ParseContext(prs->cx_, prs->pc, sc, prs->tokenStream, prs->usedNames,
+      : ParseContext(prs->cx_, prs->pc_, sc, prs->tokenStream, prs->usedNames,
                      newDirectives,
                      mozilla::IsSame<ParseHandler, FullParseHandler>::value) {}
 };
 
 enum VarContext { HoistVars, DontHoistVars };
 enum PropListType { ObjectLiteral, ClassBody, DerivedClassBody };
 enum class PropertyType {
   Normal,
@@ -253,17 +253,17 @@ class MOZ_STACK_CLASS ParserBase : priva
 
   TokenStreamAnyChars anyChars;
   LifoAlloc::Mark tempPoolMark_;
 
   /* list of parsed objects and BigInts for GC tracing */
   TraceListNode* traceListHead_;
 
   /* innermost parse context (stack-allocated) */
-  ParseContext* pc;
+  ParseContext* pc_;
 
   // For tracking used names in this parsing session.
   UsedNameTracker& usedNames;
 
   ScriptSource* ss;
 
   RootedScriptSourceObject sourceObject;
 
@@ -311,29 +311,29 @@ class MOZ_STACK_CLASS ParserBase : priva
   bool checkOptions();
 
   void trace(JSTracer* trc);
 
   const char* getFilename() const { return anyChars.getFilename(); }
   TokenPos pos() const { return anyChars.currentToken().pos; }
 
   // Determine whether |yield| is a valid name in the current context.
-  bool yieldExpressionsSupported() const { return pc->isGenerator(); }
+  bool yieldExpressionsSupported() const { return pc_->isGenerator(); }
 
   bool setLocalStrictMode(bool strict) {
     MOZ_ASSERT(anyChars.debugHasNoLookahead());
-    return pc->sc()->setLocalStrictMode(strict);
+    return pc_->sc()->setLocalStrictMode(strict);
   }
 
  public:
   // Implement ErrorReportMixin.
 
   JSContext* getContext() const override { return cx_; }
 
-  bool strictMode() const override { return pc->sc()->strict(); }
+  bool strictMode() const override { return pc_->sc()->strict(); }
 
   const JS::ReadOnlyCompileOptions& options() const override {
     return anyChars.options();
   }
 
   using Base::error;
   using Base::errorAt;
   using Base::errorNoOffset;
@@ -781,17 +781,17 @@ class MOZ_STACK_CLASS GeneralParser : pu
   using Base::warningWithNotesAt;
   using Base::warningWithNotesNoOffset;
 
  public:
   using Base::anyChars;
   using Base::cx_;
   using Base::handler;
   using Base::isValidSimpleAssignmentTarget;
-  using Base::pc;
+  using Base::pc_;
   using Base::usedNames;
 
  private:
   using Base::checkAndMarkSuperScope;
   using Base::declareDotGeneratorName;
   using Base::declareFunctionArgumentsObject;
   using Base::declareFunctionThis;
   using Base::finishFunction;
@@ -1071,17 +1071,17 @@ class MOZ_STACK_CLASS GeneralParser : pu
       const mozilla::Maybe<uint32_t>& parameterListEnd = mozilla::Nothing(),
       bool isStandaloneFunction = false);
 
  private:
   /*
    * JS parsers, from lowest to highest precedence.
    *
    * Each parser must be called during the dynamic scope of a ParseContext
-   * object, pointed to by this->pc.
+   * object, pointed to by this->pc_.
    *
    * Each returns a parse node tree or null on error.
    */
   FunctionNodeType functionStmt(
       uint32_t toStringStart, YieldHandling yieldHandling,
       DefaultHandling defaultHandling,
       FunctionAsyncKind asyncKind = FunctionAsyncKind::SyncFunction);
   FunctionNodeType functionExpr(uint32_t toStringStart,
@@ -1500,17 +1500,17 @@ class MOZ_STACK_CLASS Parser<SyntaxParse
   using Base::mustMatchToken;
   using Base::newFunctionBox;
   using Base::newLexicalScopeData;
   using Base::newModuleScopeData;
   using Base::newName;
   using Base::noteDeclaredName;
   using Base::null;
   using Base::options;
-  using Base::pc;
+  using Base::pc_;
   using Base::pos;
   using Base::propagateFreeNamesAndMarkClosedOverBindings;
   using Base::ss;
   using Base::statementList;
   using Base::stringLiteral;
   using Base::usedNames;
 
  private:
@@ -1597,17 +1597,17 @@ class MOZ_STACK_CLASS Parser<FullParseHa
  public:
   using Base::anyChars;
   using Base::clearAbortedSyntaxParse;
   using Base::functionFormalParametersAndBody;
   using Base::hadAbortedSyntaxParse;
   using Base::handler;
   using Base::newFunctionBox;
   using Base::options;
-  using Base::pc;
+  using Base::pc_;
   using Base::pos;
   using Base::ss;
   using Base::tokenStream;
 
  public:
   // ErrorReportMixin.
 
   using Base::error;
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -1950,18 +1950,18 @@ class MOZ_STACK_CLASS JS_HAZ_ROOTED Modu
     asmJSMetadata_ = cx_->new_<AsmJSMetadata>();
     if (!asmJSMetadata_) {
       return false;
     }
 
     asmJSMetadata_->toStringStart =
         moduleFunctionNode_->funbox()->toStringStart;
     asmJSMetadata_->srcStart = moduleFunctionNode_->body()->pn_pos.begin;
-    asmJSMetadata_->strict =
-        parser_.pc->sc()->strict() && !parser_.pc->sc()->hasExplicitUseStrict();
+    asmJSMetadata_->strict = parser_.pc_->sc()->strict() &&
+                             !parser_.pc_->sc()->hasExplicitUseStrict();
     asmJSMetadata_->scriptSource.reset(parser_.ss);
 
     if (!addStandardLibraryMathInfo()) {
       return false;
     }
 
     if (!initDummyFunction()) {
       return false;
@@ -6019,17 +6019,17 @@ static bool ParseFunction(ModuleValidato
   if (!funNode) {
     return false;
   }
 
   RootedFunction& fun = m.dummyFunction();
   fun->setAtom(name);
   fun->setArgCount(0);
 
-  ParseContext* outerpc = m.parser().pc;
+  ParseContext* outerpc = m.parser().pc_;
   Directives directives(outerpc);
   FunctionBox* funbox = m.parser().newFunctionBox(
       funNode, fun, toStringStart, directives, GeneratorKind::NotGenerator,
       FunctionAsyncKind::SyncFunction);
   if (!funbox) {
     return false;
   }
   funbox->initWithEnclosingParseContext(outerpc, FunctionSyntaxKind::Statement);
@@ -6348,17 +6348,17 @@ static bool CheckModuleEnd(ModuleValidat
   return true;
 }
 
 template <typename Unit>
 static SharedModule CheckModule(JSContext* cx, AsmJSParser<Unit>& parser,
                                 ParseNode* stmtList, unsigned* time) {
   int64_t before = PRMJ_Now();
 
-  FunctionNode* moduleFunctionNode = parser.pc->functionBox()->functionNode;
+  FunctionNode* moduleFunctionNode = parser.pc_->functionBox()->functionNode;
 
   ModuleValidator<Unit> m(cx, parser, moduleFunctionNode);
   if (!m.init()) {
     return nullptr;
   }
 
   if (!CheckFunctionHead(m, moduleFunctionNode)) {
     return nullptr;
@@ -7031,30 +7031,30 @@ static bool EstablishPreconditions(JSCon
     case AsmJSOption::Disabled:
       return TypeFailureWarning(parser, "Disabled by 'asmjs' runtime option");
     case AsmJSOption::DisabledByDebugger:
       return TypeFailureWarning(parser, "Disabled by debugger");
     case AsmJSOption::Enabled:
       break;
   }
 
-  if (parser.pc->isGenerator()) {
+  if (parser.pc_->isGenerator()) {
     return TypeFailureWarning(parser, "Disabled by generator context");
   }
 
-  if (parser.pc->isAsync()) {
+  if (parser.pc_->isAsync()) {
     return TypeFailureWarning(parser, "Disabled by async context");
   }
 
-  if (parser.pc->isArrowFunction()) {
+  if (parser.pc_->isArrowFunction()) {
     return TypeFailureWarning(parser, "Disabled by arrow function context");
   }
 
   // Class constructors are also methods
-  if (parser.pc->isMethod() || parser.pc->isGetterOrSetter()) {
+  if (parser.pc_->isMethod() || parser.pc_->isGetterOrSetter()) {
     return TypeFailureWarning(
         parser, "Disabled by class constructor or method context");
   }
 
   return true;
 }
 
 template <typename Unit>
@@ -7080,17 +7080,17 @@ static bool DoCompileAsmJS(JSContext* cx
   Rooted<WasmModuleObject*> moduleObj(cx,
                                       WasmModuleObject::create(cx, *module));
   if (!moduleObj) {
     return false;
   }
 
   // The module function dynamically links the AsmJSModule when called and
   // generates a set of functions wrapping all the exports.
-  FunctionBox* funbox = parser.pc->functionBox();
+  FunctionBox* funbox = parser.pc_->functionBox();
   RootedFunction moduleFun(
       cx, NewAsmJSModuleFunction(cx, funbox->function(), moduleObj));
   if (!moduleFun) {
     return false;
   }
 
   // Finished! Clobber the default function created by the parser with the new
   // asm.js module function. Special cases in the bytecode emitter avoid