Introduce parent ScopeState class and track the scope through the state in the parser

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 181 matching lines @@
   Scope* function_scope = NewScope(scope, FUNCTION_SCOPE, kind);
   SetLanguageMode(function_scope,
                   static_cast<LanguageMode>(language_mode | STRICT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
   ZoneList<Statement*>* body = NULL;
 
   {
     AstNodeFactory function_factory(ast_value_factory());
-    FunctionState function_state(&function_state_, &scope_, function_scope,
+    FunctionState function_state(&function_state_, &state_, function_scope,
                                  kind, &function_factory);
 
     body = new (zone()) ZoneList<Statement*>(call_super ? 2 : 1, zone());
     if (call_super) {
       // $super_constructor = %_GetSuperConstructor(<this-function>)
       // %reflect_construct(
       //     $super_constructor, InternalArray(...args), new.target)
       auto constructor_args_name = ast_value_factory()->empty_string();
       bool is_duplicate;
       bool is_rest = true;
       bool is_optional = false;
       Variable* constructor_args =
           function_scope->DeclareParameter(constructor_args_name, TEMPORARY,
                                            is_optional, is_rest, &is_duplicate);
 
       ZoneList<Expression*>* args =
           new (zone()) ZoneList<Expression*>(2, zone());
-      VariableProxy* this_function_proxy = scope_->NewUnresolved(
+      VariableProxy* this_function_proxy = this->scope()->NewUnresolved(
           factory(), ast_value_factory()->this_function_string(),
           Variable::NORMAL, pos);
       ZoneList<Expression*>* tmp =
           new (zone()) ZoneList<Expression*>(1, zone());
       tmp->Add(this_function_proxy, zone());
       Expression* super_constructor = factory()->NewCallRuntime(
           Runtime::kInlineGetSuperConstructor, tmp, pos);
       args->Add(super_constructor, zone());
       Spread* spread_args = factory()->NewSpread(
           factory()->NewVariableProxy(constructor_args), pos, pos);
       ZoneList<Expression*>* spread_args_expr =
           new (zone()) ZoneList<Expression*>(1, zone());
       spread_args_expr->Add(spread_args, zone());
       args->AddAll(*PrepareSpreadArguments(spread_args_expr), zone());
-      VariableProxy* new_target_proxy = scope_->NewUnresolved(
+      VariableProxy* new_target_proxy = this->scope()->NewUnresolved(
           factory(), ast_value_factory()->new_target_string(), Variable::NORMAL,
           pos);
       args->Add(new_target_proxy, zone());
       CallRuntime* call = factory()->NewCallRuntime(
           Context::REFLECT_CONSTRUCT_INDEX, args, pos);
       body->Add(factory()->NewReturnStatement(call, pos), zone());
     }
 
     materialized_literal_count = function_state.materialized_literal_count();
     expected_property_count = function_state.expected_property_count();
@@ skipping 649 matching lines @@
     log_ = NULL;
   }
   return result;
 }
 
 
 FunctionLiteral* Parser::DoParseProgram(ParseInfo* info) {
   // Note that this function can be called from the main thread or from a
   // background thread. We should not access anything Isolate / heap dependent
   // via ParseInfo, and also not pass it forward.
-  DCHECK(scope_ == NULL);
-  DCHECK(target_stack_ == NULL);
+  DCHECK_NULL(state_);
+  DCHECK_NULL(target_stack_);
 
   Mode parsing_mode = FLAG_lazy && allow_lazy() ? PARSE_LAZILY : PARSE_EAGERLY;
   if (allow_natives() || extension_ != NULL) parsing_mode = PARSE_EAGERLY;
 
   FunctionLiteral* result = NULL;
   {
     // TODO(wingo): Add an outer SCRIPT_SCOPE corresponding to the native
     // context, which will have the "this" binding for script scopes.
-    Scope* scope = NewScope(scope_, SCRIPT_SCOPE);
+    Scope* scope = NewScope(nullptr, SCRIPT_SCOPE);
     info->set_script_scope(scope);
     if (!info->context().is_null() && !info->context()->IsNativeContext()) {
       scope = Scope::DeserializeScopeChain(info->isolate(), zone(),
                                            *info->context(), scope);
       // The Scope is backed up by ScopeInfo (which is in the V8 heap); this
       // means the Parser cannot operate independent of the V8 heap. Tell the
       // string table to internalize strings and values right after they're
       // created. This kind of parsing can only be done in the main thread.
       DCHECK(parsing_on_main_thread_);
       ast_value_factory()->Internalize(info->isolate());
     }
     original_scope_ = scope;
     if (info->is_eval()) {
       if (!scope->is_script_scope() || is_strict(info->language_mode())) {
         parsing_mode = PARSE_EAGERLY;
       }
       scope = NewScope(scope, EVAL_SCOPE);
     } else if (info->is_module()) {
       scope = NewScope(scope, MODULE_SCOPE);
     }
 
     scope->set_start_position(0);
 
     // Enter 'scope' with the given parsing mode.
     ParsingModeScope parsing_mode_scope(this, parsing_mode);
     AstNodeFactory function_factory(ast_value_factory());
-    FunctionState function_state(&function_state_, &scope_, scope,
+    FunctionState function_state(&function_state_, &state_, scope,
                                  kNormalFunction, &function_factory);
 
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     parsing_module_ = info->is_module();
     if (parsing_module_) {
       ParseModuleItemList(body, &ok);
       ok = ok &&
-           scope_->module()->Validate(scope_, &pending_error_handler_, zone());
+           module()->Validate(this->scope(), &pending_error_handler_, zone());
     } else {
       // Don't count the mode in the use counters--give the program a chance
       // to enable script-wide strict mode below.
-      scope_->SetLanguageMode(info->language_mode());
+      this->scope()->SetLanguageMode(info->language_mode());
       ParseStatementList(body, Token::EOS, &ok);
     }
 
     // The parser will peek but not consume EOS.  Our scope logically goes all
     // the way to the EOS, though.
     scope->set_end_position(scanner()->peek_location().beg_pos);
 
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
       CheckDecimalLiteralWithLeadingZero(use_counts_, beg_pos,
                                          scanner()->location().end_pos);
     }
     if (ok && is_sloppy(language_mode())) {
       // TODO(littledan): Function bindings on the global object that modify
       // pre-existing bindings should be made writable, enumerable and
       // nonconfigurable if possible, whereas this code will leave attributes
       // unchanged if the property already exists.
       InsertSloppyBlockFunctionVarBindings(scope, nullptr, &ok);
     }
     if (ok) {
-      CheckConflictingVarDeclarations(scope_, &ok);
+      CheckConflictingVarDeclarations(this->scope(), &ok);
     }
 
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
         ReportMessage(MessageTemplate::kSingleFunctionLiteral);
         ok = false;
       }
     }
 
     if (ok) {
       ParserTraits::RewriteDestructuringAssignments();
       result = factory()->NewScriptOrEvalFunctionLiteral(
-          scope_, body, function_state.materialized_literal_count(),
+          this->scope(), body, function_state.materialized_literal_count(),
           function_state.expected_property_count());
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
 }
 
@@ skipping 48 matching lines @@
              IsAccessorFunction(shared_info->kind())) {
     return FunctionLiteral::kAccessorOrMethod;
   }
   return FunctionLiteral::kAnonymousExpression;
 }
 
 FunctionLiteral* Parser::ParseLazy(Isolate* isolate, ParseInfo* info,
                                    Utf16CharacterStream* source) {
   Handle<SharedFunctionInfo> shared_info = info->shared_info();
   scanner_.Initialize(source);
-  DCHECK(scope_ == NULL);
-  DCHECK(target_stack_ == NULL);
+  DCHECK_NULL(state_);
+  DCHECK_NULL(target_stack_);
 
   Handle<String> name(String::cast(shared_info->name()));
   DCHECK(ast_value_factory());
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   const AstRawString* raw_name = ast_value_factory()->GetString(name);
   fni_->PushEnclosingName(raw_name);
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
-  FunctionLiteral* result = NULL;
+  FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
-    Scope* scope = NewScope(scope_, SCRIPT_SCOPE);
+    Scope* scope = NewScope(nullptr, SCRIPT_SCOPE);
     info->set_script_scope(scope);
     if (!info->context().is_null()) {
       // Ok to use Isolate here, since lazy function parsing is only done in the
       // main thread.
       DCHECK(parsing_on_main_thread_);
       scope = Scope::DeserializeScopeChain(isolate, zone(), *info->context(),
                                            scope);
     }
     original_scope_ = scope;
     AstNodeFactory function_factory(ast_value_factory());
-    FunctionState function_state(&function_state_, &scope_, scope,
+    FunctionState function_state(&function_state_, &state_, scope,
                                  shared_info->kind(), &function_factory);
     DCHECK(is_sloppy(scope->language_mode()) ||
            is_strict(info->language_mode()));
     DCHECK(info->language_mode() == shared_info->language_mode());
     FunctionLiteral::FunctionType function_type =
         ComputeFunctionType(shared_info);
     bool ok = true;
 
     if (shared_info->is_arrow()) {
       bool is_async = allow_harmony_async_await() && shared_info->is_async();
       if (is_async) {
         DCHECK(!scanner()->HasAnyLineTerminatorAfterNext());
         if (!Check(Token::ASYNC)) {
           CHECK(stack_overflow());
           return nullptr;
         }
         if (!(peek_any_identifier() || peek() == Token::LPAREN)) {
           CHECK(stack_overflow());
           return nullptr;
         }
       }
 
       // TODO(adamk): We should construct this scope from the ScopeInfo.
       Scope* scope =
-          NewScope(scope_, FUNCTION_SCOPE, FunctionKind::kArrowFunction);
+          NewScope(this->scope(), FUNCTION_SCOPE, FunctionKind::kArrowFunction);
 
       // These two bits only need to be explicitly set because we're
       // not passing the ScopeInfo to the Scope constructor.
       // TODO(adamk): Remove these calls once the above NewScope call
       // passes the ScopeInfo.
       if (shared_info->scope_info()->CallsEval()) {
         scope->RecordEvalCall();
       }
       SetLanguageMode(scope, shared_info->language_mode());
 
       scope->set_start_position(shared_info->start_position());
       ExpressionClassifier formals_classifier(this);
       ParserFormalParameters formals(scope);
       Checkpoint checkpoint(this);
       {
         // Parsing patterns as variable reference expression creates
         // NewUnresolved references in current scope. Entrer arrow function
         // scope for formal parameter parsing.
-        BlockState block_state(&scope_, scope);
+        BlockState block_state(&state_, scope);
         if (Check(Token::LPAREN)) {
           // '(' StrictFormalParameters ')'
           ParseFormalParameterList(&formals, &formals_classifier, &ok);
           if (ok) ok = Check(Token::RPAREN);
         } else {
           // BindingIdentifier
           ParseFormalParameter(&formals, &formals_classifier, &ok);
           if (ok) {
             DeclareFormalParameter(formals.scope, formals.at(0),
                                    &formals_classifier);
@@ skipping 29 matching lines @@
           raw_name, IsSubclassConstructor(shared_info->kind()), scope,
           shared_info->start_position(), shared_info->end_position(),
           shared_info->language_mode());
     } else {
       result = ParseFunctionLiteral(raw_name, Scanner::Location::invalid(),
                                     kSkipFunctionNameCheck, shared_info->kind(),
                                     kNoSourcePosition, function_type,
                                     shared_info->language_mode(), &ok);
     }
     // Make sure the results agree.
-    DCHECK(ok == (result != NULL));
+    DCHECK(ok == (result != nullptr));
   }
 
   // Make sure the target stack is empty.
-  DCHECK(target_stack_ == NULL);
+  DCHECK_NULL(target_stack_);
 
-  if (result != NULL) {
+  if (result != nullptr) {
     Handle<String> inferred_name(shared_info->inferred_name());
     result->set_inferred_name(inferred_name);
   }
   return result;
 }
 
 
 void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
                                  bool* ok) {
   // StatementList ::
@@ skipping 28 matching lines @@
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
           (literal = e_stat->expression()->AsLiteral()) != NULL &&
           literal->raw_value()->IsString()) {
         // Check "use strict" directive (ES5 14.1), "use asm" directive.
         bool use_strict_found =
             literal->raw_value()->AsString() ==
                 ast_value_factory()->use_strict_string() &&
             token_loc.end_pos - token_loc.beg_pos ==
                 ast_value_factory()->use_strict_string()->length() + 2;
         if (use_strict_found) {
-          if (is_sloppy(scope_->language_mode())) {
+          if (is_sloppy(this->scope()->language_mode())) {
             RaiseLanguageMode(STRICT);
           }
 
-          if (!scope_->HasSimpleParameters()) {
+          if (!this->scope()->HasSimpleParameters()) {

[marja, 2016/07/19 07:54:42]

(Style) Why so much "this->"? Afaics it's only needed inside the template
classes but not here.

             // TC39 deemed "use strict" directives to be an error when occurring
             // in the body of a function with non-simple parameter list, on
             // 29/7/2015. https://goo.gl/ueA7Ln
             const AstRawString* string = literal->raw_value()->AsString();
             ParserTraits::ReportMessageAt(
                 token_loc, MessageTemplate::kIllegalLanguageModeDirective,
                 string);
             *ok = false;
             return nullptr;
           }
           // Because declarations in strict eval code don't leak into the scope
           // of the eval call, it is likely that functions declared in strict
           // eval code will be used within the eval code, so lazy parsing is
           // probably not a win.
-          if (scope_->is_eval_scope()) mode_ = PARSE_EAGERLY;
+          if (this->scope()->is_eval_scope()) mode_ = PARSE_EAGERLY;
         } else if (literal->raw_value()->AsString() ==
                        ast_value_factory()->use_asm_string() &&
                    token_loc.end_pos - token_loc.beg_pos ==
                        ast_value_factory()->use_asm_string()->length() + 2) {
           // Store the usage count; The actual use counter on the isolate is
           // incremented after parsing is done.
           ++use_counts_[v8::Isolate::kUseAsm];
-          scope_->SetAsmModule();
+          this->scope()->SetAsmModule();
         } else {
           // Should not change mode, but will increment UseCounter
           // if appropriate. Ditto usages below.
           RaiseLanguageMode(SLOPPY);
         }
       } else {
         // End of the directive prologue.
         directive_prologue = false;
         RaiseLanguageMode(SLOPPY);
       }
@@ skipping 64 matching lines @@
 
 void* Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
   // ecma262/#prod-Module
   // Module :
   //    ModuleBody?
   //
   // ecma262/#prod-ModuleItemList
   // ModuleBody :
   //    ModuleItem*
 
-  DCHECK(scope_->is_module_scope());
+  DCHECK(scope()->is_module_scope());
   while (peek() != Token::EOS) {
     Statement* stat = ParseModuleItem(CHECK_OK);
     if (stat && !stat->IsEmpty()) {
       body->Add(stat, zone());
     }
   }
   return nullptr;
 }
 
 
@@ skipping 124 matching lines @@
 
   int pos = peek_position();
   Expect(Token::IMPORT, CHECK_OK);
 
   Token::Value tok = peek();
 
   // 'import' ModuleSpecifier ';'
   if (tok == Token::STRING) {
     const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
     ExpectSemicolon(CHECK_OK);
-    scope_->module()->AddEmptyImport(
-        module_specifier, scanner()->location(), zone());
+    module()->AddEmptyImport(module_specifier, scanner()->location(), zone());
     return nullptr;
   }
 
   // Parse ImportedDefaultBinding if present.
   const AstRawString* import_default_binding = nullptr;
   Scanner::Location import_default_binding_loc;
   if (tok != Token::MUL && tok != Token::LBRACE) {
     import_default_binding =
         ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
     import_default_binding_loc = scanner()->location();
@@ skipping 27 matching lines @@
   }
 
   ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
   const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
   ExpectSemicolon(CHECK_OK);
 
   // Now that we have all the information, we can make the appropriate
   // declarations.
 
   if (module_namespace_binding != nullptr) {
-    scope_->module()->AddStarImport(
-        module_namespace_binding, module_specifier,
-        module_namespace_binding_loc, zone());
+    module()->AddStarImport(module_namespace_binding, module_specifier,
+                            module_namespace_binding_loc, zone());
     // TODO(neis): Create special immutable binding for the namespace object.
   }
 
   // TODO(neis): Would prefer to call DeclareImport below rather than above and
   // in ParseNamedImports, but then a possible error message would point to the
   // wrong location.  Maybe have a DeclareAt version of Declare that takes a
   // location?
 
   if (import_default_binding != nullptr) {
-    scope_->module()->AddImport(
-        ast_value_factory()->default_string(), import_default_binding,
-        module_specifier, import_default_binding_loc, zone());
+    module()->AddImport(ast_value_factory()->default_string(),
+                        import_default_binding, module_specifier,
+                        import_default_binding_loc, zone());
     // DeclareImport(import_default_binding, pos, CHECK_OK);
   }
 
   if (named_imports != nullptr) {
     if (named_imports->length() == 0) {
-      scope_->module()->AddEmptyImport(
-          module_specifier, scanner()->location(), zone());
+      module()->AddEmptyImport(module_specifier, scanner()->location(), zone());
     } else {
       for (int i = 0; i < named_imports->length(); ++i) {
         const NamedImport* import = named_imports->at(i);
-        scope_->module()->AddImport(
-            import->import_name, import->local_name,
-            module_specifier, import->location, zone());
+        module()->AddImport(import->import_name, import->local_name,
+                            module_specifier, import->location, zone());
         // DeclareImport(import->local_name, pos, CHECK_OK);
       }
     }
   }
 
   return nullptr;
 }
 
 
 Statement* Parser::ParseExportDefault(bool* ok) {
@@ skipping 35 matching lines @@
       SetFunctionName(value, ast_value_factory()->default_string());
 
       const AstRawString* local_name =
           ast_value_factory()->star_default_star_string();
       local_names.Add(local_name, zone());
 
       // It's fine to declare this as CONST because the user has no way of
       // writing to it.
       VariableProxy* proxy = NewUnresolved(local_name, CONST);
       Declaration* declaration =
-          factory()->NewVariableDeclaration(proxy, CONST, scope_, pos);
+          factory()->NewVariableDeclaration(proxy, CONST, scope(), pos);
       Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
       proxy->var()->set_initializer_position(position());
 
       Assignment* assignment = factory()->NewAssignment(
           Token::INIT, proxy, value, kNoSourcePosition);
       result = factory()->NewExpressionStatement(assignment, kNoSourcePosition);
 
       ExpectSemicolon(CHECK_OK);
       break;
     }
   }
 
   DCHECK_EQ(local_names.length(), 1);
-  scope_->module()->AddExport(
-      local_names.first(), ast_value_factory()->default_string(), default_loc,
-      zone());
+  module()->AddExport(local_names.first(),
+                      ast_value_factory()->default_string(), default_loc,
+                      zone());
 
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
   //    'export' '*' 'from' ModuleSpecifier ';'
   //    'export' ExportClause ('from' ModuleSpecifier)? ';'
   //    'export' VariableStatement
   //    'export' Declaration
   //    'export' 'default' ... (handled in ParseExportDefault)
 
   int pos = peek_position();
   Expect(Token::EXPORT, CHECK_OK);
 
   Statement* result = nullptr;
   ZoneList<const AstRawString*> names(1, zone());
   switch (peek()) {
     case Token::DEFAULT:
       return ParseExportDefault(ok);
 
     case Token::MUL: {
       Consume(Token::MUL);
       ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
       const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
       ExpectSemicolon(CHECK_OK);
-      scope_->module()->AddStarExport(
-          module_specifier, scanner()->location(), zone());
+      module()->AddStarExport(module_specifier, scanner()->location(), zone());
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::LBRACE: {
       // There are two cases here:
       //
       // 'export' ExportClause ';'
       // and
       // 'export' ExportClause FromClause ';'
       //
@@ skipping 16 matching lines @@
         *ok = false;
         ReportMessageAt(reserved_loc, MessageTemplate::kUnexpectedReserved);
         return nullptr;
       }
       ExpectSemicolon(CHECK_OK);
       const int length = export_names.length();
       DCHECK_EQ(length, original_names.length());
       DCHECK_EQ(length, export_locations.length());
       if (module_specifier == nullptr) {
         for (int i = 0; i < length; ++i) {
-          scope_->module()->AddExport(original_names[i], export_names[i],
-                                      export_locations[i], zone());
+          module()->AddExport(original_names[i], export_names[i],
+                              export_locations[i], zone());
         }
       } else if (length == 0) {
-        scope_->module()->AddEmptyImport(
-            module_specifier, scanner()->location(), zone());
+        module()->AddEmptyImport(module_specifier, scanner()->location(),
+                                 zone());
       } else {
         for (int i = 0; i < length; ++i) {
-          scope_->module()->AddExport(
-              original_names[i], export_names[i], module_specifier,
-              export_locations[i], zone());
+          module()->AddExport(original_names[i], export_names[i],
+                              module_specifier, export_locations[i], zone());
         }
       }
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::FUNCTION:
       result = ParseHoistableDeclaration(&names, false, CHECK_OK);
       break;
 
     case Token::CLASS:
@@ skipping 16 matching lines @@
         break;
       }
     /* falls through */
 
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
       return nullptr;
   }
 
-  ModuleDescriptor* descriptor = scope_->module();
+  ModuleDescriptor* descriptor = module();
   for (int i = 0; i < names.length(); ++i) {
     // TODO(neis): Provide better location.
     descriptor->AddExport(names[i], names[i], scanner()->location(), zone());
   }
 
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 Statement* Parser::ParseStatement(ZoneList<const AstRawString*>* labels,
@@ skipping 129 matching lines @@
   }
 }
 
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name,
                                      VariableMode mode) {
   // If we are inside a function, a declaration of a 'var' variable is a
   // truly local variable, and the scope of the variable is always the function
   // scope.
   // Let/const variables are always added to the immediately enclosing scope.
-  Scope* scope =
-      IsLexicalVariableMode(mode) ? scope_ : scope_->DeclarationScope();
+  Scope* scope = IsLexicalVariableMode(mode)
+                     ? this->scope()
+                     : this->scope()->DeclarationScope();
   return scope->NewUnresolved(factory(), name, Variable::NORMAL,
                               scanner()->location().beg_pos,
                               scanner()->location().end_pos);
 }
 
 
 void* Parser::DeclareImport(const AstRawString* local_name, int pos, bool* ok) {
   DCHECK_NOT_NULL(local_name);
   VariableProxy* proxy = NewUnresolved(local_name, IMPORT);
   Declaration* declaration =
-      factory()->NewVariableDeclaration(proxy, IMPORT, scope_, pos);
+      factory()->NewVariableDeclaration(proxy, IMPORT, scope(), pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   return nullptr;
 }
 
 
 Variable* Parser::Declare(Declaration* declaration,
                           DeclarationDescriptor::Kind declaration_kind,
                           bool resolve, bool* ok, Scope* scope) {
   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
   VariableMode mode = declaration->mode();
   DCHECK(IsDeclaredVariableMode(mode) && mode != CONST_LEGACY);
   bool is_function_declaration = declaration->IsFunctionDeclaration();
-  if (scope == nullptr) scope = scope_;
+  if (scope == nullptr) scope = this->scope();
   Scope* declaration_scope =
       IsLexicalVariableMode(mode) ? scope : scope->DeclarationScope();
   Variable* var = NULL;
 
   // If a suitable scope exists, then we can statically declare this
   // variable and also set its mode. In any case, a Declaration node
   // will be added to the scope so that the declaration can be added
   // to the corresponding activation frame at runtime if necessary.
   // For instance, var declarations inside a sloppy eval scope need
   // to be added to the calling function context. Similarly, strict
@@ skipping 151 matching lines @@
     }
   }
   Expect(Token::RPAREN, CHECK_OK);
   Expect(Token::SEMICOLON, CHECK_OK);
 
   // Make sure that the function containing the native declaration
   // isn't lazily compiled. The extension structures are only
   // accessible while parsing the first time not when reparsing
   // because of lazy compilation.
   // TODO(adamk): Should this be ClosureScope()?
-  scope_->DeclarationScope()->ForceEagerCompilation();
+  scope()->DeclarationScope()->ForceEagerCompilation();
 
   // TODO(1240846): It's weird that native function declarations are
   // introduced dynamically when we meet their declarations, whereas
   // other functions are set up when entering the surrounding scope.
   VariableProxy* proxy = NewUnresolved(name, VAR);
   Declaration* declaration =
-      factory()->NewVariableDeclaration(proxy, VAR, scope_, pos);
+      factory()->NewVariableDeclaration(proxy, VAR, scope(), pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   NativeFunctionLiteral* lit =
       factory()->NewNativeFunctionLiteral(name, extension_, kNoSourcePosition);
   return factory()->NewExpressionStatement(
       factory()->NewAssignment(Token::INIT, proxy, lit, kNoSourcePosition),
       pos);
 }
 
 Statement* Parser::ParseHoistableDeclaration(
     ZoneList<const AstRawString*>* names, bool default_export, bool* ok) {
@@ skipping 65 matching lines @@
   FunctionLiteral* fun = ParseFunctionLiteral(
       name, scanner()->location(), name_validity,
       is_generator ? FunctionKind::kGeneratorFunction
                    : is_async ? FunctionKind::kAsyncFunction
                               : FunctionKind::kNormalFunction,
       pos, FunctionLiteral::kDeclaration, language_mode(), CHECK_OK);
 
   // In ES6, a function behaves as a lexical binding, except in
   // a script scope, or the initial scope of eval or another function.
   VariableMode mode =
-      (!scope_->is_declaration_scope() || scope_->is_module_scope()) ? LET
-                                                                     : VAR;
+      (!scope()->is_declaration_scope() || scope()->is_module_scope()) ? LET
+                                                                       : VAR;
   VariableProxy* proxy = NewUnresolved(variable_name, mode);
   Declaration* declaration =
-      factory()->NewFunctionDeclaration(proxy, mode, fun, scope_, pos);
+      factory()->NewFunctionDeclaration(proxy, mode, fun, scope(), pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   if (names) names->Add(variable_name, zone());
   EmptyStatement* empty = factory()->NewEmptyStatement(kNoSourcePosition);
   // Async functions don't undergo sloppy mode block scoped hoisting, and don't
   // allow duplicates in a block. Both are represented by the
   // sloppy_block_function_map. Don't add them to the map for async functions.
   // Generators are also supposed to be prohibited; currently doing this behind
   // a flag and UseCounting violations to assess web compatibility.
-  if (is_sloppy(language_mode()) && !scope_->is_declaration_scope() &&
+  if (is_sloppy(language_mode()) && !scope()->is_declaration_scope() &&
       !is_async && !(allow_harmony_restrictive_generators() && is_generator)) {
     SloppyBlockFunctionStatement* delegate =
-        factory()->NewSloppyBlockFunctionStatement(empty, scope_);
-    scope_->DeclarationScope()->sloppy_block_function_map()->Declare(
+        factory()->NewSloppyBlockFunctionStatement(empty, scope());
+    scope()->DeclarationScope()->sloppy_block_function_map()->Declare(
         variable_name, delegate);
     return delegate;
   }
   return empty;
 }
 
 Statement* Parser::ParseClassDeclaration(ZoneList<const AstRawString*>* names,
                                          bool default_export, bool* ok) {
   // ClassDeclaration ::
   //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
@@ skipping 25 matching lines @@
   } else {
     name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
     variable_name = name;
   }
 
   ClassLiteral* value = ParseClassLiteral(nullptr, name, scanner()->location(),
                                           is_strict_reserved, pos, CHECK_OK);
 
   VariableProxy* proxy = NewUnresolved(variable_name, LET);
   Declaration* declaration =
-      factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
+      factory()->NewVariableDeclaration(proxy, LET, scope(), pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   proxy->var()->set_initializer_position(position());
   Assignment* assignment =
       factory()->NewAssignment(Token::INIT, proxy, value, pos);
   Statement* assignment_statement =
       factory()->NewExpressionStatement(assignment, kNoSourcePosition);
   if (names) names->Add(variable_name, zone());
   return assignment_statement;
 }
 
 
 Block* Parser::ParseBlock(ZoneList<const AstRawString*>* labels,
                           bool finalize_block_scope, bool* ok) {
   // The harmony mode uses block elements instead of statements.
   //
   // Block ::
   //   '{' StatementList '}'
 
   // Construct block expecting 16 statements.
   Block* body = factory()->NewBlock(labels, 16, false, kNoSourcePosition);
-  Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
 
   // Parse the statements and collect escaping labels.
   Expect(Token::LBRACE, CHECK_OK);
   block_scope->set_start_position(scanner()->location().beg_pos);
-  { BlockState block_state(&scope_, block_scope);
+  {
+    BlockState block_state(&state_, block_scope);
     Target target(&this->target_stack_, body);
 
     while (peek() != Token::RBRACE) {
       Statement* stat = ParseStatementListItem(CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->statements()->Add(stat, zone());
       }
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
@@ skipping 85 matching lines @@
     DCHECK(var_context != kStatement);
     parsing_result->descriptor.mode = CONST;
   } else if (peek() == Token::LET) {
     Consume(Token::LET);
     DCHECK(var_context != kStatement);
     parsing_result->descriptor.mode = LET;
   } else {
     UNREACHABLE();  // by current callers
   }
 
-  parsing_result->descriptor.scope = scope_;
+  parsing_result->descriptor.scope = scope();
   parsing_result->descriptor.hoist_scope = nullptr;
 
 
   bool first_declaration = true;
   int bindings_start = peek_position();
   do {
     FuncNameInferrer::State fni_state(fni_);
 
     // Parse name.
     if (!first_declaration) Consume(Token::COMMA);
@@ skipping 167 matching lines @@
       *ok = false;
       return NULL;
     }
     if (labels == NULL) {
       labels = new(zone()) ZoneList<const AstRawString*>(4, zone());
     }
     labels->Add(label, zone());
     // Remove the "ghost" variable that turned out to be a label
     // from the top scope. This way, we don't try to resolve it
     // during the scope processing.
-    scope_->RemoveUnresolved(var);
+    scope()->RemoveUnresolved(var);
     Expect(Token::COLON, CHECK_OK);
     // ES#sec-labelled-function-declarations Labelled Function Declarations
     if (peek() == Token::FUNCTION && is_sloppy(language_mode())) {
       if (allow_function == kAllowLabelledFunctionStatement) {
         return ParseFunctionDeclaration(ok);
       } else {
         return ParseScopedStatement(labels, true, ok);
       }
     }
     return ParseStatement(labels, kDisallowLabelledFunctionStatement, ok);
@@ skipping 118 matching lines @@
   function_state_->set_return_location(loc);
 
   Token::Value tok = peek();
   Statement* result;
   Expression* return_value;
   if (scanner()->HasAnyLineTerminatorBeforeNext() ||
       tok == Token::SEMICOLON ||
       tok == Token::RBRACE ||
       tok == Token::EOS) {
     if (IsSubclassConstructor(function_state_->kind())) {
-      return_value = ThisExpression(scope_, factory(), loc.beg_pos);
+      return_value = ThisExpression(scope(), factory(), loc.beg_pos);
     } else {
       return_value = GetLiteralUndefined(position());
     }
   } else {
     int pos = peek_position();
 
     if (IsSubclassConstructor(function_state_->kind())) {
       // Because of the return code rewriting that happens in case of a subclass
       // constructor we don't want to accept tail calls, therefore we don't set
       // ReturnExprScope to kInsideValidReturnStatement here.
       return_value = ParseExpression(true, CHECK_OK);
 
       // For subclass constructors we need to return this in case of undefined
       // return a Smi (transformed into an exception in the ConstructStub)
       // for a non object.
       //
       //   return expr;
       //
       // Is rewritten as:
       //
       //   return (temp = expr) === undefined ? this :
       //       %_IsJSReceiver(temp) ? temp : 1;
 
       // temp = expr
-      Variable* temp = scope_->NewTemporary(
-          ast_value_factory()->empty_string());
+      Variable* temp =
+          scope()->NewTemporary(ast_value_factory()->empty_string());
       Assignment* assign = factory()->NewAssignment(
           Token::ASSIGN, factory()->NewVariableProxy(temp), return_value, pos);
 
       // %_IsJSReceiver(temp)
       ZoneList<Expression*>* is_spec_object_args =
           new (zone()) ZoneList<Expression*>(1, zone());
       is_spec_object_args->Add(factory()->NewVariableProxy(temp), zone());
       Expression* is_spec_object_call = factory()->NewCallRuntime(
           Runtime::kInlineIsJSReceiver, is_spec_object_args, pos);
 
       // %_IsJSReceiver(temp) ? temp : 1;
       Expression* is_object_conditional = factory()->NewConditional(
           is_spec_object_call, factory()->NewVariableProxy(temp),
           factory()->NewSmiLiteral(1, pos), pos);
 
       // temp === undefined
       Expression* is_undefined = factory()->NewCompareOperation(
           Token::EQ_STRICT, assign,
           factory()->NewUndefinedLiteral(kNoSourcePosition), pos);
 
       // is_undefined ? this : is_object_conditional
       return_value = factory()->NewConditional(
-          is_undefined, ThisExpression(scope_, factory(), pos),
+          is_undefined, ThisExpression(scope(), factory(), pos),
           is_object_conditional, pos);
     } else {
       ReturnExprScope maybe_allow_tail_calls(
           function_state_, ReturnExprContext::kInsideValidReturnStatement);
       return_value = ParseExpression(true, CHECK_OK);
 
       if (allow_tailcalls() && !is_sloppy(language_mode())) {
         // ES6 14.6.1 Static Semantics: IsInTailPosition
         function_state_->AddImplicitTailCallExpression(return_value);
       }
     }
   }
   ExpectSemicolon(CHECK_OK);
 
   if (is_generator()) {
     return_value = BuildIteratorResult(return_value, true);
   } else if (is_async_function()) {
     return_value = BuildPromiseResolve(return_value, return_value->position());
   }
 
   result = factory()->NewReturnStatement(return_value, loc.beg_pos);
 
-  Scope* decl_scope = scope_->DeclarationScope();
+  Scope* decl_scope = scope()->DeclarationScope();
   if (decl_scope->is_script_scope() || decl_scope->is_eval_scope()) {
     ReportMessageAt(loc, MessageTemplate::kIllegalReturn);
     *ok = false;
     return NULL;
   }
   return result;
 }
 
 
 Statement* Parser::ParseWithStatement(ZoneList<const AstRawString*>* labels,
                                       bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
 
   Expect(Token::WITH, CHECK_OK);
   int pos = position();
 
   if (is_strict(language_mode())) {
     ReportMessage(MessageTemplate::kStrictWith);
     *ok = false;
     return NULL;
   }
 
   Expect(Token::LPAREN, CHECK_OK);
   Expression* expr = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
-  Scope* with_scope = NewScope(scope_, WITH_SCOPE);
+  Scope* with_scope = NewScope(scope(), WITH_SCOPE);
   Statement* body;
-  { BlockState block_state(&scope_, with_scope);
+  {
+    BlockState block_state(&state_, with_scope);
     with_scope->set_start_position(scanner()->peek_location().beg_pos);
     body = ParseScopedStatement(labels, true, CHECK_OK);
     with_scope->set_end_position(scanner()->location().end_pos);
   }
   return factory()->NewWithStatement(with_scope, expr, body, pos);
 }
 
 
 CaseClause* Parser::ParseCaseClause(bool* default_seen_ptr, bool* ok) {
   // CaseClause ::
@@ skipping 44 matching lines @@
 
   Block* switch_block = factory()->NewBlock(NULL, 2, false, kNoSourcePosition);
   int switch_pos = peek_position();
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   Variable* tag_variable =
-      scope_->NewTemporary(ast_value_factory()->dot_switch_tag_string());
+      scope()->NewTemporary(ast_value_factory()->dot_switch_tag_string());
   Assignment* tag_assign = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(tag_variable), tag,
       tag->position());
   Statement* tag_statement =
       factory()->NewExpressionStatement(tag_assign, kNoSourcePosition);
   switch_block->statements()->Add(tag_statement, zone());
 
   // make statement: undefined;
   // This is needed so the tag isn't returned as the value, in case the switch
   // statements don't have a value.
   switch_block->statements()->Add(
       factory()->NewExpressionStatement(
           factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition),
       zone());
 
   Block* cases_block = factory()->NewBlock(NULL, 1, false, kNoSourcePosition);
-  Scope* cases_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* cases_scope = NewScope(scope(), BLOCK_SCOPE);
   cases_scope->SetNonlinear();
 
   SwitchStatement* switch_statement =
       factory()->NewSwitchStatement(labels, switch_pos);
 
   cases_scope->set_start_position(scanner()->location().beg_pos);
   {
-    BlockState cases_block_state(&scope_, cases_scope);
+    BlockState cases_block_state(&state_, cases_scope);
     Target target(&this->target_stack_, switch_statement);
 
     Expression* tag_read = factory()->NewVariableProxy(tag_variable);
 
     bool default_seen = false;
     ZoneList<CaseClause*>* cases =
         new (zone()) ZoneList<CaseClause*>(4, zone());
     Expect(Token::LBRACE, CHECK_OK);
     while (peek() != Token::RBRACE) {
       CaseClause* clause = ParseCaseClause(&default_seen, CHECK_OK);
@@ skipping 63 matching lines @@
   }
 
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
   TailCallExpressionList tail_call_expressions_in_catch_block(zone());
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
-    catch_scope = NewScope(scope_, CATCH_SCOPE);
+    catch_scope = NewScope(scope(), CATCH_SCOPE);
     catch_scope->set_start_position(scanner()->location().beg_pos);
 
     {
       CollectExpressionsInTailPositionToListScope
           collect_tail_call_expressions_scope(
               function_state_, &tail_call_expressions_in_catch_block);
-      BlockState block_state(&scope_, catch_scope);
+      BlockState block_state(&state_, catch_scope);
 
       catch_block = factory()->NewBlock(nullptr, 16, false, kNoSourcePosition);
 
       // Create a block scope to hold any lexical declarations created
       // as part of destructuring the catch parameter.
-      Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
+      Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
       block_scope->set_start_position(scanner()->location().beg_pos);
       {
-        BlockState block_state(&scope_, block_scope);
+        BlockState block_state(&state_, block_scope);
         Target target(&this->target_stack_, catch_block);
 
         const AstRawString* name = ast_value_factory()->dot_catch_string();
         Expression* pattern = nullptr;
         if (peek_any_identifier()) {
           name = ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
         } else {
           ExpressionClassifier pattern_classifier(this);
           pattern = ParsePrimaryExpression(&pattern_classifier, CHECK_OK);
           ValidateBindingPattern(&pattern_classifier, CHECK_OK);
         }
         catch_variable = catch_scope->DeclareLocal(
             name, VAR, kCreatedInitialized, Variable::NORMAL);
 
         Expect(Token::RPAREN, CHECK_OK);
 
         ZoneList<const AstRawString*> bound_names(1, zone());
         if (pattern != nullptr) {
           DeclarationDescriptor descriptor;
           descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
           descriptor.parser = this;
-          descriptor.scope = scope_;
+          descriptor.scope = scope();
           descriptor.hoist_scope = nullptr;
           descriptor.mode = LET;
           descriptor.declaration_pos = pattern->position();
           descriptor.initialization_pos = pattern->position();
 
           // Initializer position for variables declared by the pattern.
           const int initializer_position = position();
 
           DeclarationParsingResult::Declaration decl(
               pattern, initializer_position,
@@ skipping 181 matching lines @@
                                               Statement* body,
                                               int each_keyword_pos) {
   ForOfStatement* for_of = stmt->AsForOfStatement();
   if (for_of != NULL) {
     const bool finalize = true;
     return InitializeForOfStatement(for_of, each, subject, body, finalize,
                                     each_keyword_pos);
   } else {
     if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
       Variable* temp =
-          scope_->NewTemporary(ast_value_factory()->empty_string());
+          scope()->NewTemporary(ast_value_factory()->empty_string());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
       Expression* assign_each = PatternRewriter::RewriteDestructuringAssignment(
           this, factory()->NewAssignment(Token::ASSIGN, each, temp_proxy,
                                          kNoSourcePosition),
-          scope_);
+          scope());
       auto block = factory()->NewBlock(nullptr, 2, false, kNoSourcePosition);
       block->statements()->Add(
           factory()->NewExpressionStatement(assign_each, kNoSourcePosition),
           zone());
       block->statements()->Add(body, zone());
       body = block;
       each = factory()->NewVariableProxy(temp);
     }
     stmt->AsForInStatement()->Initialize(each, subject, body);
   }
   return stmt;
 }
 
 Statement* Parser::InitializeForOfStatement(ForOfStatement* for_of,
                                             Expression* each,
                                             Expression* iterable,
                                             Statement* body, bool finalize,
                                             int next_result_pos) {
   // Create the auxiliary expressions needed for iterating over the iterable,
   // and initialize the given ForOfStatement with them.
   // If finalize is true, also instrument the loop with code that performs the
   // proper ES6 iterator finalization.  In that case, the result is not
   // immediately a ForOfStatement.
 
   const int nopos = kNoSourcePosition;
   auto avfactory = ast_value_factory();
 
   Variable* iterator =
-      scope_->NewTemporary(ast_value_factory()->dot_iterator_string());
+      scope()->NewTemporary(ast_value_factory()->dot_iterator_string());
   Variable* result =
-      scope_->NewTemporary(ast_value_factory()->dot_result_string());
-  Variable* completion = scope_->NewTemporary(avfactory->empty_string());
+      scope()->NewTemporary(ast_value_factory()->dot_result_string());
+  Variable* completion = scope()->NewTemporary(avfactory->empty_string());
 
   // iterator = iterable[Symbol.iterator]()
   Expression* assign_iterator;
   {
     assign_iterator = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
         GetIterator(iterable, factory(), iterable->position()),
         iterable->position());
   }
 
@@ skipping 35 matching lines @@
 
     Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
     block->statements()->Add(
         factory()->NewExpressionStatement(assignment, nopos), zone());
     set_completion_abrupt = block;
   }
 
   // do { let tmp = #result_value; #set_completion_abrupt; tmp }
   // Expression* result_value (gets overwritten)
   if (finalize) {
-    Variable* var_tmp = scope_->NewTemporary(avfactory->empty_string());
+    Variable* var_tmp = scope()->NewTemporary(avfactory->empty_string());
     Expression* tmp = factory()->NewVariableProxy(var_tmp);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, tmp, result_value, nopos);
 
     Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
     block->statements()->Add(
         factory()->NewExpressionStatement(assignment, nopos), zone());
     block->statements()->Add(set_completion_abrupt, zone());
 
     result_value = factory()->NewDoExpression(block, var_tmp, nopos);
   }
 
   // each = #result_value;
   Expression* assign_each;
   {
     assign_each =
         factory()->NewAssignment(Token::ASSIGN, each, result_value, nopos);
     if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
       assign_each = PatternRewriter::RewriteDestructuringAssignment(
-          this, assign_each->AsAssignment(), scope_);
+          this, assign_each->AsAssignment(), scope());
     }
   }
 
   // {{completion = kNormalCompletion;}}
   Statement* set_completion_normal;
   if (finalize) {
     Expression* proxy = factory()->NewVariableProxy(completion);
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, proxy,
         factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
@@ skipping 69 matching lines @@
 
   // Add statement: let/const x = i.
   outer_block->statements()->Add(init, zone());
 
   const AstRawString* temp_name = ast_value_factory()->dot_for_string();
 
   // For each lexical variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy = NewUnresolved(names->at(i), LET);
-    Variable* temp = scope_->NewTemporary(temp_name);
+    Variable* temp = scope()->NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(Token::ASSIGN, temp_proxy,
                                                       proxy, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
     outer_block->statements()->Add(assignment_statement, zone());
     temps.Add(temp, zone());
   }
 
   Variable* first = NULL;
   // Make statement: first = 1.
   if (next) {
-    first = scope_->NewTemporary(temp_name);
+    first = scope()->NewTemporary(temp_name);
     VariableProxy* first_proxy = factory()->NewVariableProxy(first);
     Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, first_proxy, const1, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
     outer_block->statements()->Add(assignment_statement, zone());
   }
 
   // make statement: undefined;
   outer_block->statements()->Add(
       factory()->NewExpressionStatement(
           factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition),
       zone());
 
   // Make statement: outer: for (;;)
   // Note that we don't actually create the label, or set this loop up as an
   // explicit break target, instead handing it directly to those nodes that
   // need to know about it. This should be safe because we don't run any code
   // in this function that looks up break targets.
   ForStatement* outer_loop =
       factory()->NewForStatement(NULL, kNoSourcePosition);
   outer_block->statements()->Add(outer_loop, zone());
-  outer_block->set_scope(scope_);
+  outer_block->set_scope(scope());
 
   Block* inner_block = factory()->NewBlock(NULL, 3, false, kNoSourcePosition);
   {
-    BlockState block_state(&scope_, inner_scope);
+    BlockState block_state(&state_, inner_scope);
 
     Block* ignore_completion_block =
         factory()->NewBlock(NULL, names->length() + 3, true, kNoSourcePosition);
     ZoneList<Variable*> inner_vars(names->length(), zone());
     // For each let variable x:
     //    make statement: let/const x = temp_x.
     for (int i = 0; i < names->length(); i++) {
       VariableProxy* proxy = NewUnresolved(names->at(i), mode);
       Declaration* declaration = factory()->NewVariableDeclaration(
-          proxy, mode, scope_, kNoSourcePosition);
+          proxy, mode, scope(), kNoSourcePosition);
       Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
       inner_vars.Add(declaration->proxy()->var(), zone());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
       Assignment* assignment = factory()->NewAssignment(
           Token::INIT, proxy, temp_proxy, kNoSourcePosition);
       Statement* assignment_statement =
           factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       DCHECK(init->position() != kNoSourcePosition);
       proxy->var()->set_initializer_position(init->position());
       ignore_completion_block->statements()->Add(assignment_statement, zone());
@@ skipping 18 matching lines @@
         Assignment* assignment = factory()->NewAssignment(
             Token::ASSIGN, first_proxy, const0, kNoSourcePosition);
         clear_first =
             factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       }
       Statement* clear_first_or_next = factory()->NewIfStatement(
           compare, clear_first, next, kNoSourcePosition);
       ignore_completion_block->statements()->Add(clear_first_or_next, zone());
     }
 
-    Variable* flag = scope_->NewTemporary(temp_name);
+    Variable* flag = scope()->NewTemporary(temp_name);
     // Make statement: flag = 1.
     {
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, flag_proxy, const1, kNoSourcePosition);
       Statement* assignment_statement =
           factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       ignore_completion_block->statements()->Add(assignment_statement, zone());
     }
@@ skipping 86 matching lines @@
                                         bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
     return ParseSubStatement(labels, kDisallowLabelledFunctionStatement, ok);
   } else {
     if (legacy) {
       ++use_counts_[v8::Isolate::kLegacyFunctionDeclaration];
     }
     // Make a block around the statement for a lexical binding
     // is introduced by a FunctionDeclaration.
-    Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
+    Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
     body_scope->set_start_position(scanner()->location().beg_pos);
-    BlockState block_state(&scope_, body_scope);
+    BlockState block_state(&state_, body_scope);
     Block* block = factory()->NewBlock(NULL, 1, false, kNoSourcePosition);
     Statement* body = ParseFunctionDeclaration(CHECK_OK);
     block->statements()->Add(body, zone());
     body_scope->set_end_position(scanner()->location().end_pos);
     body_scope = body_scope->FinalizeBlockScope();
     block->set_scope(body_scope);
     return block;
   }
 }
 
 Statement* Parser::ParseForStatement(ZoneList<const AstRawString*>* labels,
                                      bool* ok) {
   int stmt_pos = peek_position();
   Statement* init = NULL;
   ZoneList<const AstRawString*> bound_names(1, zone());
   bool bound_names_are_lexical = false;
 
   // Create an in-between scope for let-bound iteration variables.
-  Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* for_scope = NewScope(scope(), BLOCK_SCOPE);
 
-  BlockState block_state(&scope_, for_scope);
+  BlockState block_state(&state_, for_scope);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_scope->set_start_position(scanner()->location().beg_pos);
   for_scope->set_is_hidden();
   DeclarationParsingResult parsing_result;
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && IsNextLetKeyword())) {
       ParseVariableDeclarations(kForStatement, &parsing_result, nullptr,
                                 CHECK_OK);
@@ skipping 35 matching lines @@
         bound_names_are_lexical =
             IsLexicalVariableMode(parsing_result.descriptor.mode);
 
         // special case for legacy for (var ... = ... in ...)
         if (!bound_names_are_lexical && decl.pattern->IsVariableProxy() &&
             decl.initializer != nullptr) {
           DCHECK(!allow_harmony_for_in());
           ++use_counts_[v8::Isolate::kForInInitializer];
           const AstRawString* name =
               decl.pattern->AsVariableProxy()->raw_name();
-          VariableProxy* single_var = scope_->NewUnresolved(
+          VariableProxy* single_var = scope()->NewUnresolved(
               factory(), name, Variable::NORMAL, each_beg_pos, each_end_pos);
           init_block = factory()->NewBlock(
               nullptr, 2, true, parsing_result.descriptor.declaration_pos);
           init_block->statements()->Add(
               factory()->NewExpressionStatement(
                   factory()->NewAssignment(Token::ASSIGN, single_var,
                                            decl.initializer, kNoSourcePosition),
                   kNoSourcePosition),
               zone());
         }
 
         // Rewrite a for-in/of statement of the form
         //
         //   for (let/const/var x in/of e) b
         //
         // into
         //
         //   {
         //     <let x' be a temporary variable>
         //     for (x' in/of e) {
         //       let/const/var x;
         //       x = x';
         //       b;
         //     }
         //     let x;  // for TDZ
         //   }
 
         Variable* temp =
-            scope_->NewTemporary(ast_value_factory()->dot_for_string());
+            scope()->NewTemporary(ast_value_factory()->dot_for_string());
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, stmt_pos);
         Target target(&this->target_stack_, loop);
 
         int each_keyword_position = scanner()->location().beg_pos;
 
         Expression* enumerable;
         if (mode == ForEachStatement::ITERATE) {
           ExpressionClassifier classifier(this);
           enumerable = ParseAssignmentExpression(true, &classifier, CHECK_OK);
           RewriteNonPattern(&classifier, CHECK_OK);
         } else {
           enumerable = ParseExpression(true, CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
 
-        Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
+        Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
         body_scope->set_start_position(scanner()->location().beg_pos);
 
         Block* body_block =
             factory()->NewBlock(NULL, 3, false, kNoSourcePosition);
 
         Statement* final_loop;
         {
           ReturnExprScope no_tail_calls(function_state_,
                                         ReturnExprContext::kInsideForInOfBody);
-          BlockState block_state(&scope_, body_scope);
+          BlockState block_state(&state_, body_scope);
 
           Statement* body = ParseScopedStatement(NULL, true, CHECK_OK);
 
           auto each_initialization_block =
               factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
           {
             auto descriptor = parsing_result.descriptor;
             descriptor.declaration_pos = kNoSourcePosition;
             descriptor.initialization_pos = kNoSourcePosition;
             decl.initializer = factory()->NewVariableProxy(temp);
 
             bool is_for_var_of =
                 mode == ForEachStatement::ITERATE &&
                 parsing_result.descriptor.mode == VariableMode::VAR;
 
             PatternRewriter::DeclareAndInitializeVariables(
                 each_initialization_block, &descriptor, &decl,
                 bound_names_are_lexical || is_for_var_of ? &bound_names
                                                          : nullptr,
                 CHECK_OK);
 
             // Annex B.3.5 prohibits the form
             // `try {} catch(e) { for (var e of {}); }`
             // So if we are parsing a statement like `for (var ... of ...)`
             // we need to walk up the scope chain and look for catch scopes
             // which have a simple binding, then compare their binding against
             // all of the names declared in the init of the for-of we're
             // parsing.
             if (is_for_var_of) {
-              Scope* catch_scope = scope_;
+              Scope* catch_scope = scope();
               while (catch_scope != nullptr &&
                      !catch_scope->is_declaration_scope()) {
                 if (catch_scope->is_catch_scope()) {
                   auto name = catch_scope->catch_variable_name();
                   if (name !=
                       ast_value_factory()
                           ->dot_catch_string()) {  // i.e. is a simple binding
                     if (bound_names.Contains(name)) {
                       ParserTraits::ReportMessageAt(
                           parsing_result.bindings_loc,
@@ skipping 25 matching lines @@
 
           init_block =
               factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
 
           for (int i = 0; i < bound_names.length(); ++i) {
             // TODO(adamk): This needs to be some sort of special
             // INTERNAL variable that's invisible to the debugger
             // but visible to everything else.
             VariableProxy* tdz_proxy = NewUnresolved(bound_names[i], LET);
             Declaration* tdz_decl = factory()->NewVariableDeclaration(
-                tdz_proxy, LET, scope_, kNoSourcePosition);
+                tdz_proxy, LET, scope(), kNoSourcePosition);
             Variable* tdz_var = Declare(
                 tdz_decl, DeclarationDescriptor::NORMAL, true, CHECK_OK);
             tdz_var->set_initializer_position(position());
           }
         }
 
         for_scope->set_end_position(scanner()->location().end_pos);
         for_scope = for_scope->FinalizeBlockScope();
         // Parsed for-in loop w/ variable declarations.
         if (init_block != nullptr) {
@@ skipping 75 matching lines @@
 
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
 
   Expression* cond = NULL;
   Statement* next = NULL;
   Statement* body = NULL;
 
   // If there are let bindings, then condition and the next statement of the
   // for loop must be parsed in a new scope.
-  Scope* inner_scope = scope_;
+  Scope* inner_scope = scope();
   if (bound_names_are_lexical && bound_names.length() > 0) {
     inner_scope = NewScope(for_scope, BLOCK_SCOPE);
     inner_scope->set_start_position(scanner()->location().beg_pos);
   }
   {
-    BlockState block_state(&scope_, inner_scope);
+    BlockState block_state(&state_, inner_scope);
 
     if (peek() != Token::SEMICOLON) {
       cond = ParseExpression(true, CHECK_OK);
     }
     Expect(Token::SEMICOLON, CHECK_OK);
 
     if (peek() != Token::RPAREN) {
       Expression* exp = ParseExpression(true, CHECK_OK);
       next = factory()->NewExpressionStatement(exp, exp->position());
     }
     Expect(Token::RPAREN, CHECK_OK);
 
     body = ParseScopedStatement(NULL, true, CHECK_OK);
   }
 
   Statement* result = NULL;
   if (bound_names_are_lexical && bound_names.length() > 0) {
-    BlockState block_state(&scope_, for_scope);
+    BlockState block_state(&state_, for_scope);
     result = DesugarLexicalBindingsInForStatement(
         inner_scope, parsing_result.descriptor.mode, &bound_names, loop, init,
         cond, next, body, CHECK_OK);
     for_scope->set_end_position(scanner()->location().end_pos);
   } else {
     for_scope->set_end_position(scanner()->location().end_pos);
     for_scope = for_scope->FinalizeBlockScope();
     if (for_scope) {
       // Rewrite a for statement of the form
       //   for (const x = i; c; n) b
@@ skipping 128 matching lines @@
     parameters->is_simple = !is_rest && expr->IsVariableProxy();
   }
 
   Expression* initializer = nullptr;
   if (expr->IsVariableProxy()) {
     // When the formal parameter was originally seen, it was parsed as a
     // VariableProxy and recorded as unresolved in the scope.  Here we undo that
     // parse-time side-effect for parameters that are single-names (not
     // patterns; for patterns that happens uniformly in
     // PatternRewriter::VisitVariableProxy).
-    parser_->scope_->RemoveUnresolved(expr->AsVariableProxy());
+    parser_->scope()->RemoveUnresolved(expr->AsVariableProxy());
   } else if (expr->IsAssignment()) {
     Assignment* assignment = expr->AsAssignment();
     DCHECK(!assignment->is_compound());
     initializer = assignment->value();
     expr = assignment->target();
 
     // TODO(adamk): Only call this if necessary.
     RewriteParameterInitializerScope(parser_->stack_limit(), initializer,
-                                     parser_->scope_, parameters->scope);
+                                     parser_->scope(), parameters->scope);
   }
 
   AddFormalParameter(parameters, expr, initializer, end_pos, is_rest);
 }
 
 void ParserTraits::ParseAsyncArrowSingleExpressionBody(
     ZoneList<Statement*>* body, bool accept_IN,
     Type::ExpressionClassifier* classifier, int pos, bool* ok) {
   parser_->DesugarAsyncFunctionBody(
-      parser_->ast_value_factory()->empty_string(), parser_->scope_, body,
+      parser_->ast_value_factory()->empty_string(), parser_->scope(), body,
       classifier, kAsyncArrowFunction, FunctionBody::SingleExpression,
       accept_IN, pos, ok);
 }
 
 void Parser::DesugarAsyncFunctionBody(const AstRawString* function_name,
                                       Scope* scope, ZoneList<Statement*>* body,
                                       ExpressionClassifier* classifier,
                                       FunctionKind kind, FunctionBody body_type,
                                       bool accept_IN, int pos, bool* ok) {
   // function async_function() {
   //   try {
   //     .generator_object = %CreateGeneratorObject();
   //     ... function body ...
   //   } catch (e) {
   //     return Promise.reject(e);
   //   }
   // }
   scope->ForceContextAllocation();
-  Variable* temp =
-      scope_->NewTemporary(ast_value_factory()->dot_generator_object_string());
+  Variable* temp = this->scope()->NewTemporary(
+      ast_value_factory()->dot_generator_object_string());
   function_state_->set_generator_object_variable(temp);
 
   Expression* init_generator_variable = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(temp),
       BuildCreateJSGeneratorObject(pos, kind), kNoSourcePosition);
   body->Add(factory()->NewExpressionStatement(init_generator_variable,
                                               kNoSourcePosition),
             zone());
 
   Block* try_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
@@ skipping 20 matching lines @@
   scope->set_end_position(scanner()->location().end_pos);
 }
 
 DoExpression* Parser::ParseDoExpression(bool* ok) {
   // AssignmentExpression ::
   //     do '{' StatementList '}'
   int pos = peek_position();
 
   Expect(Token::DO, CHECK_OK);
   Variable* result =
-      scope_->NewTemporary(ast_value_factory()->dot_result_string());
+      scope()->NewTemporary(ast_value_factory()->dot_result_string());
   Block* block = ParseBlock(nullptr, false, CHECK_OK);
   DoExpression* expr = factory()->NewDoExpression(block, result, pos);
   if (!Rewriter::Rewrite(this, expr, ast_value_factory())) {
     *ok = false;
     return nullptr;
   }
   block->set_scope(block->scope()->FinalizeBlockScope());
   return expr;
 }
 
@@ skipping 65 matching lines @@
   // Anonymous functions were passed either the empty symbol or a null
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = ast_value_factory()->empty_string();
   }
 
-  Scope* scope = NewScope(scope_, FUNCTION_SCOPE, kind);
+  Scope* scope = NewScope(this->scope(), FUNCTION_SCOPE, kind);
   SetLanguageMode(scope, language_mode);
   ZoneList<Statement*>* body = NULL;
   int arity = -1;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   bool should_be_used_once_hint = false;
   bool has_duplicate_parameters;
   FunctionLiteral::EagerCompileHint eager_compile_hint;
 
   // Parse function.
   {
     AstNodeFactory function_factory(ast_value_factory());
-    FunctionState function_state(&function_state_, &scope_, scope, kind,
+    FunctionState function_state(&function_state_, &state_, scope, kind,
                                  &function_factory);
-    scope_->SetScopeName(function_name);
+    this->scope()->SetScopeName(function_name);
     ExpressionClassifier formals_classifier(this, &duplicate_finder);
 
     eager_compile_hint = function_state_->this_function_is_parenthesized()
                              ? FunctionLiteral::kShouldEagerCompile
                              : FunctionLiteral::kShouldLazyCompile;
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.  The machine code produced for generators (by full-codegen)
       // relies on this forced context allocation, but not in an essential way.
-      scope_->ForceContextAllocation();
+      this->scope()->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
-      Variable* temp = scope_->NewTemporary(
+      Variable* temp = this->scope()->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
-    scope_->set_start_position(start_position);
+    this->scope()->set_start_position(start_position);
     ParserFormalParameters formals(scope);
     ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
     arity = formals.Arity();
     Expect(Token::RPAREN, CHECK_OK);
     int formals_end_position = scanner()->location().end_pos;
 
     CheckArityRestrictions(arity, kind, formals.has_rest, start_position,
                            formals_end_position, CHECK_OK);
     Expect(Token::LBRACE, CHECK_OK);
     // Don't include the rest parameter into the function's formal parameter
@@ skipping 28 matching lines @@
 
     // Now foo will be parsed eagerly and compiled eagerly (optimization: assume
     // parenthesis before the function means that it will be called
     // immediately). The inner function *must* be parsed eagerly to resolve the
     // possible reference to the variable in foo's scope. However, it's possible
     // that it will be compiled lazily.
 
     // To make this additional case work, both Parser and PreParser implement a
     // logic where only top-level functions will be parsed lazily.
     bool is_lazily_parsed = mode() == PARSE_LAZILY &&
-                            scope_->AllowsLazyParsing() &&
+                            this->scope()->AllowsLazyParsing() &&
                             !function_state_->this_function_is_parenthesized();
 
     // Eager or lazy parse?
     // If is_lazily_parsed, we'll parse lazy. If we can set a bookmark, we'll
     // pass it to SkipLazyFunctionBody, which may use it to abort lazy
     // parsing if it suspect that wasn't a good idea. If so, or if we didn't
     // try to lazy parse in the first place, we'll have to parse eagerly.
     Scanner::BookmarkScope bookmark(scanner());
     if (is_lazily_parsed) {
       Scanner::BookmarkScope* maybe_bookmark =
@@ skipping 146 matching lines @@
     // If we have cached data, we use it to skip parsing the function body. The
     // data contains the information we need to construct the lazy function.
     FunctionEntry entry =
         cached_parse_data_->GetFunctionEntry(function_block_pos);
     // Check that cached data is valid. If not, mark it as invalid (the embedder
     // handles it). Note that end position greater than end of stream is safe,
     // and hard to check.
     if (entry.is_valid() && entry.end_pos() > function_block_pos) {
       scanner()->SeekForward(entry.end_pos() - 1);
 
-      scope_->set_end_position(entry.end_pos());
+      scope()->set_end_position(entry.end_pos());
       Expect(Token::RBRACE, ok);
       if (!*ok) {
         return;
       }
-      total_preparse_skipped_ += scope_->end_position() - function_block_pos;
+      total_preparse_skipped_ += scope()->end_position() - function_block_pos;
       *materialized_literal_count = entry.literal_count();
       *expected_property_count = entry.property_count();
-      SetLanguageMode(scope_, entry.language_mode());
-      if (entry.uses_super_property()) scope_->RecordSuperPropertyUsage();
-      if (entry.calls_eval()) scope_->RecordEvalCall();
+      SetLanguageMode(scope(), entry.language_mode());
+      if (entry.uses_super_property()) scope()->RecordSuperPropertyUsage();
+      if (entry.calls_eval()) scope()->RecordEvalCall();
       return;
     }
     cached_parse_data_->Reject();
   }
   // With no cached data, we partially parse the function, without building an
   // AST. This gathers the data needed to build a lazy function.
   SingletonLogger logger;
   PreParser::PreParseResult result =
       ParseLazyFunctionBodyWithPreParser(&logger, bookmark);
   if (bookmark && bookmark->HasBeenReset()) {
     return;  // Return immediately if pre-parser devided to abort parsing.
   }
   if (result == PreParser::kPreParseStackOverflow) {
     // Propagate stack overflow.
     set_stack_overflow();
     *ok = false;
     return;
   }
   if (logger.has_error()) {
     ParserTraits::ReportMessageAt(
         Scanner::Location(logger.start(), logger.end()), logger.message(),
         logger.argument_opt(), logger.error_type());
     *ok = false;
     return;
   }
-  scope_->set_end_position(logger.end());
+  scope()->set_end_position(logger.end());
   Expect(Token::RBRACE, ok);
   if (!*ok) {
     return;
   }
-  total_preparse_skipped_ += scope_->end_position() - function_block_pos;
+  total_preparse_skipped_ += scope()->end_position() - function_block_pos;
   *materialized_literal_count = logger.literals();
   *expected_property_count = logger.properties();
-  SetLanguageMode(scope_, logger.language_mode());
+  SetLanguageMode(scope(), logger.language_mode());
   if (logger.uses_super_property()) {
-    scope_->RecordSuperPropertyUsage();
+    scope()->RecordSuperPropertyUsage();
   }
   if (logger.calls_eval()) {
-    scope_->RecordEvalCall();
+    scope()->RecordEvalCall();
   }
   if (produce_cached_parse_data()) {
     DCHECK(log_);
     // Position right after terminal '}'.
     int body_end = scanner()->location().end_pos;
     log_->LogFunction(function_block_pos, body_end, *materialized_literal_count,
-                      *expected_property_count, scope_->language_mode(),
-                      scope_->uses_super_property(), scope_->calls_eval());
+                      *expected_property_count, scope()->language_mode(),
+                      scope()->uses_super_property(), scope()->calls_eval());
   }
 }
 
 
 Statement* Parser::BuildAssertIsCoercible(Variable* var) {
   // if (var === null || var === undefined)
   //     throw /* type error kNonCoercible) */;
 
   Expression* condition = factory()->NewBinaryOperation(
       Token::OR,
@@ skipping 44 matching lines @@
 
 void Parser::RewriteParameterInitializer(Expression* expr, Scope* scope) {
   InitializerRewriter rewriter(stack_limit_, expr, this, scope);
   rewriter.Run();
 }
 
 
 Block* Parser::BuildParameterInitializationBlock(
     const ParserFormalParameters& parameters, bool* ok) {
   DCHECK(!parameters.is_simple);
-  DCHECK(scope_->is_function_scope());
+  DCHECK(scope()->is_function_scope());
   Block* init_block = factory()->NewBlock(NULL, 1, true, kNoSourcePosition);
   for (int i = 0; i < parameters.params.length(); ++i) {
     auto parameter = parameters.params[i];
     if (parameter.is_rest && parameter.pattern->IsVariableProxy()) break;
     DeclarationDescriptor descriptor;
     descriptor.declaration_kind = DeclarationDescriptor::PARAMETER;
     descriptor.parser = this;
-    descriptor.scope = scope_;
+    descriptor.scope = scope();
     descriptor.hoist_scope = nullptr;
     descriptor.mode = LET;
     descriptor.declaration_pos = parameter.pattern->position();
     // The position that will be used by the AssignmentExpression
     // which copies from the temp parameter to the pattern.
     //
     // TODO(adamk): Should this be kNoSourcePosition, since
     // it's just copying from a temp var to the real param var?
     descriptor.initialization_pos = parameter.pattern->position();
     // The initializer position which will end up in,
     // Variable::initializer_position(), used for hole check elimination.
     int initializer_position = parameter.pattern->position();
     Expression* initial_value =
         factory()->NewVariableProxy(parameters.scope->parameter(i));
     if (parameter.initializer != nullptr) {
       // IS_UNDEFINED($param) ? initializer : $param
 
       // Ensure initializer is rewritten
-      RewriteParameterInitializer(parameter.initializer, scope_);
+      RewriteParameterInitializer(parameter.initializer, scope());
 
       auto condition = factory()->NewCompareOperation(
           Token::EQ_STRICT,
           factory()->NewVariableProxy(parameters.scope->parameter(i)),
           factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition);
       initial_value = factory()->NewConditional(
           condition, parameter.initializer, initial_value, kNoSourcePosition);
       descriptor.initialization_pos = parameter.initializer->position();
       initializer_position = parameter.initializer_end_position;
     }
 
-    Scope* param_scope = scope_;
+    Scope* param_scope = scope();
     Block* param_block = init_block;
-    if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
-      param_scope = NewScope(scope_, BLOCK_SCOPE);
+    if (!parameter.is_simple() && scope()->calls_sloppy_eval()) {
+      param_scope = NewScope(scope(), BLOCK_SCOPE);
       param_scope->set_is_declaration_scope();
       param_scope->set_start_position(descriptor.initialization_pos);
       param_scope->set_end_position(parameter.initializer_end_position);
       param_scope->RecordEvalCall();
       param_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
       param_block->set_scope(param_scope);
-      descriptor.hoist_scope = scope_;
+      descriptor.hoist_scope = scope();
       // Pass the appropriate scope in so that PatternRewriter can appropriately
       // rewrite inner initializers of the pattern to param_scope
       descriptor.scope = param_scope;
       // Rewrite the outer initializer to point to param_scope
-      RewriteParameterInitializerScope(stack_limit(), initial_value, scope_,
+      RewriteParameterInitializerScope(stack_limit(), initial_value, scope(),
                                        param_scope);
     }
 
     {
-      BlockState block_state(&scope_, param_scope);
+      BlockState block_state(&state_, param_scope);
       DeclarationParsingResult::Declaration decl(
           parameter.pattern, initializer_position, initial_value);
       PatternRewriter::DeclareAndInitializeVariables(param_block, &descriptor,
                                                      &decl, nullptr, CHECK_OK);
     }
 
-    if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
+    if (!parameter.is_simple() && scope()->calls_sloppy_eval()) {
       param_scope = param_scope->FinalizeBlockScope();
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);
       }
       init_block->statements()->Add(param_block, zone());
     }
   }
   return init_block;
 }
 
 Block* Parser::BuildRejectPromiseOnException(Block* block) {
   // try { <block> } catch (error) { return Promise.reject(error); }
   Block* try_block = block;
-  Scope* catch_scope = NewScope(scope_, CATCH_SCOPE);
+  Scope* catch_scope = NewScope(scope(), CATCH_SCOPE);
   catch_scope->set_is_hidden();
   Variable* catch_variable =
       catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                 kCreatedInitialized, Variable::NORMAL);
   Block* catch_block = factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
 
   Expression* promise_reject = BuildPromiseReject(
       factory()->NewVariableProxy(catch_variable), kNoSourcePosition);
 
   ReturnStatement* return_promise_reject =
       factory()->NewReturnStatement(promise_reject, kNoSourcePosition);
   catch_block->statements()->Add(return_promise_reject, zone());
   TryStatement* try_catch_statement = factory()->NewTryCatchStatement(
       try_block, catch_scope, catch_variable, catch_block, kNoSourcePosition);
 
   block = factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
   block->statements()->Add(try_catch_statement, zone());
   return block;
 }
 
 Expression* Parser::BuildCreateJSGeneratorObject(int pos, FunctionKind kind) {
   DCHECK_NOT_NULL(function_state_->generator_object_variable());
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(factory()->NewThisFunction(pos), zone());
   args->Add(IsArrowFunction(kind)
                 ? GetLiteralUndefined(pos)
-                : ThisExpression(scope_, factory(), kNoSourcePosition),
+                : ThisExpression(scope(), factory(), kNoSourcePosition),
             zone());
   return factory()->NewCallRuntime(Runtime::kCreateJSGeneratorObject, args,
                                    pos);
 }
 
 Expression* Parser::BuildPromiseResolve(Expression* value, int pos) {
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
   args->Add(value, zone());
   return factory()->NewCallRuntime(Context::PROMISE_CREATE_RESOLVED_INDEX, args,
                                    pos);
@@ skipping 21 matching lines @@
     // If we have a named function expression, we add a local variable
     // declaration to the body of the function with the name of the
     // function and let it refer to the function itself (closure).
     // Not having parsed the function body, the language mode may still change,
     // so we reserve a spot and create the actual const assignment later.
     DCHECK_EQ(kFunctionNameAssignmentIndex, result->length());
     result->Add(NULL, zone());
   }
 
   ZoneList<Statement*>* body = result;
-  Scope* inner_scope = scope_;
+  Scope* inner_scope = scope();
   Block* inner_block = nullptr;
   if (!parameters.is_simple) {
-    inner_scope = NewScope(scope_, BLOCK_SCOPE);
+    inner_scope = NewScope(scope(), BLOCK_SCOPE);
     inner_scope->set_is_declaration_scope();
     inner_scope->set_start_position(scanner()->location().beg_pos);
     inner_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
     inner_block->set_scope(inner_scope);
     body = inner_block->statements();
   }
 
   {
-    BlockState block_state(&scope_, inner_scope);
+    BlockState block_state(&state_, inner_scope);
 
     if (IsGeneratorFunction(kind)) {
       // We produce:
       //
       // try { InitialYield; ...body...; return {value: undefined, done: true} }
       // finally { %_GeneratorClose(generator) }
       //
       // - InitialYield yields the actual generator object.
       // - Any return statement inside the body will have its argument wrapped
       //   in a "done" iterator result object.
       // - If the generator terminates for whatever reason, we must close it.
       //   Hence the finally clause.
 
       Block* try_block =
           factory()->NewBlock(nullptr, 3, false, kNoSourcePosition);
 
       {
         Expression* allocation = BuildCreateJSGeneratorObject(pos, kind);
         VariableProxy* init_proxy = factory()->NewVariableProxy(
             function_state_->generator_object_variable());
         Assignment* assignment = factory()->NewAssignment(
             Token::INIT, init_proxy, allocation, kNoSourcePosition);
         VariableProxy* get_proxy = factory()->NewVariableProxy(
             function_state_->generator_object_variable());
         // The position of the yield is important for reporting the exception
         // caused by calling the .throw method on a generator suspended at the
         // initial yield (i.e. right after generator instantiation).
-        Yield* yield =
-            factory()->NewYield(get_proxy, assignment, scope_->start_position(),
-                                Yield::kOnExceptionThrow);
+        Yield* yield = factory()->NewYield(get_proxy, assignment,
+                                           scope()->start_position(),
+                                           Yield::kOnExceptionThrow);
         try_block->statements()->Add(
             factory()->NewExpressionStatement(yield, kNoSourcePosition),
             zone());
       }
 
       ParseStatementList(try_block->statements(), Token::RBRACE, CHECK_OK);
 
       Statement* final_return = factory()->NewReturnStatement(
           BuildIteratorResult(nullptr, true), kNoSourcePosition);
       try_block->statements()->Add(final_return, zone());
@@ skipping 16 matching lines @@
     } else if (IsAsyncFunction(kind)) {
       const bool accept_IN = true;
       DesugarAsyncFunctionBody(function_name, inner_scope, body, nullptr, kind,
                                FunctionBody::Normal, accept_IN, pos, CHECK_OK);
     } else {
       ParseStatementList(body, Token::RBRACE, CHECK_OK);
     }
 
     if (IsSubclassConstructor(kind)) {
       body->Add(factory()->NewReturnStatement(
-                    this->ThisExpression(scope_, factory(), kNoSourcePosition),
+                    this->ThisExpression(scope(), factory(), kNoSourcePosition),
                     kNoSourcePosition),
                 zone());
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
-  scope_->set_end_position(scanner()->location().end_pos);
+  scope()->set_end_position(scanner()->location().end_pos);
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(body, inner_block->statements());
-    SetLanguageMode(scope_, inner_scope->language_mode());
+    SetLanguageMode(scope(), inner_scope->language_mode());
     Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
 
     if (is_sloppy(inner_scope->language_mode())) {
       InsertSloppyBlockFunctionVarBindings(
           inner_scope, inner_scope->outer_scope(), CHECK_OK);
     }
 
     if (IsAsyncFunction(kind)) {
       init_block = BuildRejectPromiseOnException(init_block);
     }
@@ skipping 16 matching lines @@
   }
 
   if (function_type == FunctionLiteral::kNamedExpression) {
     // Now that we know the language mode, we can create the const assignment
     // in the previously reserved spot.
     // NOTE: We create a proxy and resolve it here so that in the
     // future we can change the AST to only refer to VariableProxies
     // instead of Variables and Proxies as is the case now.
     VariableMode fvar_mode = is_strict(language_mode()) ? CONST : CONST_LEGACY;
     Variable* fvar = new (zone())
-        Variable(scope_, function_name, fvar_mode, Variable::NORMAL,
+        Variable(scope(), function_name, fvar_mode, Variable::NORMAL,
                  kCreatedInitialized, kNotAssigned);
     VariableProxy* proxy = factory()->NewVariableProxy(fvar);
     VariableDeclaration* fvar_declaration = factory()->NewVariableDeclaration(
-        proxy, fvar_mode, scope_, kNoSourcePosition);
-    scope_->DeclareFunctionVar(fvar_declaration);
+        proxy, fvar_mode, scope(), kNoSourcePosition);
+    scope()->DeclareFunctionVar(fvar_declaration);
 
     VariableProxy* fproxy = factory()->NewVariableProxy(fvar);
     result->Set(kFunctionNameAssignmentIndex,
                 factory()->NewExpressionStatement(
                     factory()->NewAssignment(Token::INIT, fproxy,
                                              factory()->NewThisFunction(pos),
                                              kNoSourcePosition),
                     kNoSourcePosition));
   }
 
@@ skipping 22 matching lines @@
     SET_ALLOW(harmony_do_expressions);
     SET_ALLOW(harmony_for_in);
     SET_ALLOW(harmony_function_sent);
     SET_ALLOW(harmony_exponentiation_operator);
     SET_ALLOW(harmony_restrictive_declarations);
     SET_ALLOW(harmony_async_await);
     SET_ALLOW(harmony_trailing_commas);
 #undef SET_ALLOW
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
-      language_mode(), function_state_->kind(), scope_->has_simple_parameters(),
-      parsing_module_, logger, bookmark, use_counts_);
+      language_mode(), function_state_->kind(),
+      scope()->has_simple_parameters(), parsing_module_, logger, bookmark,
+      use_counts_);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
 ClassLiteral* Parser::ParseClassLiteral(ExpressionClassifier* classifier,
                                         const AstRawString* name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok) {
   // All parts of a ClassDeclaration and ClassExpression are strict code.
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location,
                     MessageTemplate::kUnexpectedStrictReserved);
     *ok = false;
     return NULL;
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
     return NULL;
   }
 
-  Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
-  BlockState block_state(&scope_, block_scope);
+  Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
+  BlockState block_state(&state_, block_scope);
   RaiseLanguageMode(STRICT);
-  scope_->SetScopeName(name);
+  scope()->SetScopeName(name);
 
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST);
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
     Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   }
 
   Expression* extends = NULL;
@@ skipping 87 matching lines @@
   Scanner::Location spread_pos;
   ExpressionClassifier classifier(this);
   ZoneList<Expression*>* args =
       ParseArguments(&spread_pos, &classifier, CHECK_OK);
 
   DCHECK(!spread_pos.IsValid());
 
   if (extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
-    scope_->DeclarationScope()->ForceEagerCompilation();
+    scope()->DeclarationScope()->ForceEagerCompilation();
   }
 
   const Runtime::Function* function = Runtime::FunctionForName(name->string());
 
   if (function != NULL) {
     // Check for possible name clash.
     DCHECK_EQ(Context::kNotFound,
               Context::IntrinsicIndexForName(name->string()));
     // Check for built-in IS_VAR macro.
     if (function->function_id == Runtime::kIS_VAR) {
@@ skipping 527 matching lines @@
     Expression* super_constructor = factory()->NewCallRuntime(
         Runtime::kInlineGetSuperConstructor, tmp, pos);
     args->InsertAt(0, super_constructor, zone());
     args->Add(function->AsSuperCallReference()->new_target_var(), zone());
     return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args,
                                      pos);
   } else {
     if (function->IsProperty()) {
       // Method calls
       if (function->AsProperty()->IsSuperAccess()) {
-        Expression* home = ThisExpression(scope_, factory(), kNoSourcePosition);
+        Expression* home =
+            ThisExpression(scope(), factory(), kNoSourcePosition);
         args->InsertAt(0, function, zone());
         args->InsertAt(1, home, zone());
       } else {
         Variable* temp =
-            scope_->NewTemporary(ast_value_factory()->empty_string());
+            scope()->NewTemporary(ast_value_factory()->empty_string());
         VariableProxy* obj = factory()->NewVariableProxy(temp);
         Assignment* assign_obj = factory()->NewAssignment(
             Token::ASSIGN, obj, function->AsProperty()->obj(),
             kNoSourcePosition);
         function = factory()->NewProperty(
             assign_obj, function->AsProperty()->key(), kNoSourcePosition);
         args->InsertAt(0, function, zone());
         obj = factory()->NewVariableProxy(temp);
         args->InsertAt(1, obj, zone());
       }
@@ skipping 24 matching lines @@
   else if (is_strict(mode))
     feature = v8::Isolate::kStrictMode;
   else
     UNREACHABLE();
   ++use_counts_[feature];
   scope->SetLanguageMode(mode);
 }
 
 
 void Parser::RaiseLanguageMode(LanguageMode mode) {
-  LanguageMode old = scope_->language_mode();
-  SetLanguageMode(scope_, old > mode ? old : mode);
+  LanguageMode old = scope()->language_mode();
+  SetLanguageMode(scope(), old > mode ? old : mode);
 }
 
 void Parser::MarkCollectedTailCallExpressions() {
   const ZoneList<Expression*>& tail_call_expressions =
       function_state_->tail_call_expressions().expressions();
   for (int i = 0; i < tail_call_expressions.length(); ++i) {
     Expression* expression = tail_call_expressions[i];
     // If only FLAG_harmony_explicit_tailcalls is enabled then expression
     // must be a Call expression.
     DCHECK(FLAG_harmony_tailcalls || !FLAG_harmony_explicit_tailcalls ||
@@ skipping 38 matching lines @@
   // yield %AsyncFunctionAwait(.generator_object, <operand>)
   Variable* generator_object_variable =
       parser_->function_state_->generator_object_variable();
 
   // If generator_object_variable is null,
   if (!generator_object_variable) return value;
 
   auto factory = parser_->factory();
   const int nopos = kNoSourcePosition;
 
-  Variable* temp_var = parser_->scope_->NewTemporary(
+  Variable* temp_var = parser_->scope()->NewTemporary(
       parser_->ast_value_factory()->empty_string());
   VariableProxy* temp_proxy = factory->NewVariableProxy(temp_var);
   Block* do_block = factory->NewBlock(nullptr, 2, false, nopos);
 
   // Wrap value evaluation to provide a break location.
   Expression* value_assignment =
       factory->NewAssignment(Token::ASSIGN, temp_proxy, value, nopos);
   do_block->statements()->Add(
       factory->NewExpressionStatement(value_assignment, value->position()),
       zone());
@@ skipping 117 matching lines @@
 Expression* Parser::RewriteAssignExponentiation(Expression* left,
                                                 Expression* right, int pos) {
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   if (left->IsVariableProxy()) {
     VariableProxy* lhs = left->AsVariableProxy();
 
     Expression* result;
     DCHECK_NOT_NULL(lhs->raw_name());
     result =
         this->ExpressionFromIdentifier(lhs->raw_name(), lhs->position(),
-                                       lhs->end_position(), scope_, factory());
+                                       lhs->end_position(), scope(), factory());
     args->Add(left, zone());
     args->Add(right, zone());
     Expression* call =
         factory()->NewCallRuntime(Context::MATH_POW_INDEX, args, pos);
     return factory()->NewAssignment(Token::ASSIGN, result, call, pos);
   } else if (left->IsProperty()) {
     Property* prop = left->AsProperty();
-    auto temp_obj = scope_->NewTemporary(ast_value_factory()->empty_string());
-    auto temp_key = scope_->NewTemporary(ast_value_factory()->empty_string());
+    auto temp_obj = scope()->NewTemporary(ast_value_factory()->empty_string());
+    auto temp_key = scope()->NewTemporary(ast_value_factory()->empty_string());
     Expression* assign_obj = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp_obj), prop->obj(),
         kNoSourcePosition);
     Expression* assign_key = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp_key), prop->key(),
         kNoSourcePosition);
     args->Add(factory()->NewProperty(factory()->NewVariableProxy(temp_obj),
                                      factory()->NewVariableProxy(temp_key),
                                      left->position()),
               zone());
@@ skipping 23 matching lines @@
   //      for ($i of x) %AppendElement($R, $i);
   //      %AppendElement($R, 4);
   //      for ($j of y) %AppendElement($R, $j);
   //      %AppendElement($R, 5);
   //      $R
   //    }
   // where $R, $i and $j are fresh temporary variables.
   ZoneList<Expression*>::iterator s = lit->FirstSpread();
   if (s == lit->EndValue()) return nullptr;  // no spread, no rewriting...
   Variable* result =
-      scope_->NewTemporary(ast_value_factory()->dot_result_string());
+      scope()->NewTemporary(ast_value_factory()->dot_result_string());
   // NOTE: The value assigned to R is the whole original array literal,
   // spreads included. This will be fixed before the rewritten AST is returned.
   // $R = lit
   Expression* init_result = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(result), lit, kNoSourcePosition);
   Block* do_block = factory()->NewBlock(nullptr, 16, false, kNoSourcePosition);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(init_result, kNoSourcePosition),
       zone());
   // Traverse the array literal starting from the first spread.
   while (s != lit->EndValue()) {
     Expression* value = *s++;
     Spread* spread = value->AsSpread();
     if (spread == nullptr) {
       // If the element is not a spread, we're adding a single:
       // %AppendElement($R, value)
       ZoneList<Expression*>* append_element_args = NewExpressionList(2, zone());
       append_element_args->Add(factory()->NewVariableProxy(result), zone());
       append_element_args->Add(value, zone());
       do_block->statements()->Add(
           factory()->NewExpressionStatement(
               factory()->NewCallRuntime(Runtime::kAppendElement,
                                         append_element_args, kNoSourcePosition),
               kNoSourcePosition),
           zone());
     } else {
       // If it's a spread, we're adding a for/of loop iterating through it.
       Variable* each =
-          scope_->NewTemporary(ast_value_factory()->dot_for_string());
+          scope()->NewTemporary(ast_value_factory()->dot_for_string());
       Expression* subject = spread->expression();
       // %AppendElement($R, each)
       Statement* append_body;
       {
         ZoneList<Expression*>* append_element_args =
             NewExpressionList(2, zone());
         append_element_args->Add(factory()->NewVariableProxy(result), zone());
         append_element_args->Add(factory()->NewVariableProxy(each), zone());
         append_body = factory()->NewExpressionStatement(
             factory()->NewCallRuntime(Runtime::kAppendElement,
@@ skipping 13 matching lines @@
   // Now, rewind the original array literal to truncate everything from the
   // first spread (included) until the end. This fixes $R's initialization.
   lit->RewindSpreads();
   return factory()->NewDoExpression(do_block, result, lit->position());
 }
 
 
 void ParserTraits::QueueDestructuringAssignmentForRewriting(Expression* expr) {
   DCHECK(expr->IsRewritableExpression());
   parser_->function_state_->AddDestructuringAssignment(
-      Parser::DestructuringAssignment(expr, parser_->scope_));
+      Parser::DestructuringAssignment(expr, parser_->scope()));
 }
 
 
 void ParserTraits::QueueNonPatternForRewriting(Expression* expr, bool* ok) {
   DCHECK(expr->IsRewritableExpression());
   parser_->function_state_->AddNonPatternForRewriting(expr, ok);
 }
 
 
 void ParserTraits::SetFunctionNameFromPropertyName(
@@ skipping 130 matching lines @@
 //   if (IS_NULL_OR_UNDEFINED(iteratorReturn)) return input;
 //   output = %_Call(iteratorReturn, iterator, input);
 //   if (!IS_RECEIVER(output)) %ThrowIterResultNotAnObject(output);
 
 Expression* ParserTraits::RewriteYieldStar(
     Expression* generator, Expression* iterable, int pos) {
   const int nopos = kNoSourcePosition;
 
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope_;
+  auto scope = parser_->scope();
   auto zone = parser_->zone();
 
 
   // Forward definition for break/continue statements.
   WhileStatement* loop = factory->NewWhileStatement(nullptr, nopos);
 
 
   // let input = undefined;
   Variable* var_input = scope->NewTemporary(avfactory->empty_string());
   Statement* initialize_input;
@@ skipping 544 matching lines @@
   //   } finally {
   //     if (condition) {
   //       #BuildIteratorCloseForCompletion(iter, completion)
   //     }
   //   }
   //
 
   const int nopos = kNoSourcePosition;
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope_;
+  auto scope = parser_->scope();
   auto zone = parser_->zone();
 
   // completion = kNormalCompletion;
   Statement* initialize_completion;
   {
     Expression* proxy = factory->NewVariableProxy(completion);
     Expression* assignment = factory->NewAssignment(
         Token::ASSIGN, proxy,
         factory->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
     initialize_completion = factory->NewExpressionStatement(assignment, nopos);
@@ skipping 98 matching lines @@
   //       if (!IS_RECEIVER(output)) {
   //         %ThrowIterResultNotAnObject(output);
   //       }
   //     }
   //   }
   //
 
   const int nopos = kNoSourcePosition;
   auto factory = parser_->factory();
   auto avfactory = parser_->ast_value_factory();
-  auto scope = parser_->scope_;
+  auto scope = parser_->scope();
   auto zone = parser_->zone();
 
 
   // let iteratorReturn = iterator.return;
   Variable* var_return = scope->NewTemporary(avfactory->empty_string());
   Statement* get_return;
   {
     Expression* iterator_proxy = factory->NewVariableProxy(iterator);
     Expression* literal =
         factory->NewStringLiteral(avfactory->return_string(), nopos);
@@ skipping 181 matching lines @@
 
 #ifdef DEBUG
 void Parser::Print(AstNode* node) {
   ast_value_factory()->Internalize(Isolate::Current());
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8