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

src/parsing/preparser.cc

 // Copyright 2011 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 <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 91 matching lines @@
 }
 
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
     LanguageMode language_mode, FunctionKind kind, bool has_simple_parameters,
     bool parsing_module, ParserRecorder* log, Scanner::BookmarkScope* bookmark,
     int* use_counts) {
   parsing_module_ = parsing_module;
   log_ = log;
   use_counts_ = use_counts;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
-  Scope* top_scope = NewScope(scope_, SCRIPT_SCOPE);
-  PreParserFactory top_factory(NULL);
-  FunctionState top_state(&function_state_, &scope_, top_scope, kNormalFunction,
+  DCHECK_NULL(state_);
+  Scope* top_scope = NewScope(nullptr, SCRIPT_SCOPE);
+  PreParserFactory top_factory(nullptr);
+  FunctionState top_state(&function_state_, &state_, top_scope, kNormalFunction,
                           &top_factory);
-  scope_->SetLanguageMode(language_mode);
-  Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE, kind);
+  scope()->SetLanguageMode(language_mode);
+  Scope* function_scope = NewScope(scope(), FUNCTION_SCOPE, kind);
   if (!has_simple_parameters) function_scope->SetHasNonSimpleParameters();
-  PreParserFactory function_factory(NULL);
-  FunctionState function_state(&function_state_, &scope_, function_scope, kind,
+  PreParserFactory function_factory(nullptr);
+  FunctionState function_state(&function_state_, &state_, function_scope, kind,
                                &function_factory);
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
   bool ok = true;
   int start_position = peek_position();
   ParseLazyFunctionLiteralBody(&ok, bookmark);
   use_counts_ = nullptr;
   if (bookmark && bookmark->HasBeenReset()) {
     // Do nothing, as we've just aborted scanning this function.
   } else if (stack_overflow()) {
     return kPreParseStackOverflow;
   } else if (!ok) {
     ReportUnexpectedToken(scanner()->current_token());
   } else {
     DCHECK_EQ(Token::RBRACE, scanner()->peek());
-    if (is_strict(scope_->language_mode())) {
+    if (is_strict(scope()->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
       CheckDecimalLiteralWithLeadingZero(use_counts, start_position, end_pos);
       if (!ok) return kPreParseSuccess;
     }
   }
   return kPreParseSuccess;
 }
 
 PreParserExpression PreParserTraits::ParseClassLiteral(
@@ skipping 80 matching lines @@
     }
     bool starts_with_identifier = peek() == Token::IDENTIFIER;
     Scanner::Location token_loc = scanner()->peek_location();
     Statement statement = ParseStatementListItem(ok);
     if (!*ok) return;
 
     if (directive_prologue) {
       bool use_strict_found = statement.IsUseStrictLiteral();
 
       if (use_strict_found) {
-        scope_->SetLanguageMode(
-            static_cast<LanguageMode>(scope_->language_mode() | STRICT));
+        scope()->SetLanguageMode(
+            static_cast<LanguageMode>(scope()->language_mode() | STRICT));
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
 
-      if (use_strict_found && !scope_->HasSimpleParameters()) {
+      if (use_strict_found && !scope()->HasSimpleParameters()) {
         // 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
         PreParserTraits::ReportMessageAt(
             token_loc, MessageTemplate::kIllegalLanguageModeDirective,
             "use strict");
         *ok = false;
         return;
       }
     }
@@ skipping 32 matching lines @@
     return Statement::Default();
   }
   return ParseSubStatement(allow_function, ok);
 }
 
 PreParser::Statement PreParser::ParseScopedStatement(bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
     return ParseSubStatement(kDisallowLabelledFunctionStatement, ok);
   } else {
-    Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
-    BlockState block_state(&scope_, body_scope);
+    Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
+    BlockState block_state(&state_, body_scope);
     return ParseFunctionDeclaration(ok);
   }
 }
 
 PreParser::Statement PreParser::ParseSubStatement(
     AllowLabelledFunctionStatement allow_function, bool* ok) {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
@@ skipping 149 matching lines @@
   ParseClassLiteral(nullptr, name, scanner()->location(), is_strict_reserved,
                     pos, CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' StatementList '}'
 
-  Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
   Expect(Token::LBRACE, CHECK_OK);
   Statement final = Statement::Default();
   {
-    BlockState block_state(&scope_, block_scope);
+    BlockState block_state(&state_, block_scope);
     while (peek() != Token::RBRACE) {
       final = ParseStatementListItem(CHECK_OK);
     }
   }
   Expect(Token::RBRACE, ok);
   return final;
 }
 
 
 PreParser::Statement PreParser::ParseVariableStatement(
@@ skipping 289 matching lines @@
   Expect(Token::WITH, CHECK_OK);
   if (is_strict(language_mode())) {
     ReportMessageAt(scanner()->location(), MessageTemplate::kStrictWith);
     *ok = false;
     return Statement::Default();
   }
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
-  Scope* with_scope = NewScope(scope_, WITH_SCOPE);
-  BlockState block_state(&scope_, with_scope);
+  Scope* with_scope = NewScope(scope(), WITH_SCOPE);
+  BlockState block_state(&state_, with_scope);
   ParseScopedStatement(true, CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
-  Scope* cases_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* cases_scope = NewScope(scope(), BLOCK_SCOPE);
   {
-    BlockState cases_block_state(&scope_, cases_scope);
+    BlockState cases_block_state(&state_, cases_scope);
     Expect(Token::LBRACE, CHECK_OK);
     Token::Value token = peek();
     while (token != Token::RBRACE) {
       if (token == Token::CASE) {
         Expect(Token::CASE, CHECK_OK);
         ParseExpression(true, CHECK_OK);
       } else {
         Expect(Token::DEFAULT, CHECK_OK);
       }
       Expect(Token::COLON, CHECK_OK);
@@ skipping 38 matching lines @@
   ParseScopedStatement(true, ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseForStatement(bool* ok) {
   // ForStatement ::
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
 
   // Create an in-between scope for let-bound iteration variables.
-  Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
+  Scope* for_scope = NewScope(scope(), BLOCK_SCOPE);
   bool has_lexical = false;
 
-  BlockState block_state(&scope_, for_scope);
+  BlockState block_state(&state_, for_scope);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   if (peek() != Token::SEMICOLON) {
     ForEachStatement::VisitMode mode;
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && IsNextLetKeyword())) {
       int decl_count;
       bool is_lexical;
       bool is_binding_pattern;
       Scanner::Location first_initializer_loc = Scanner::Location::invalid();
@@ skipping 67 matching lines @@
 
         if (mode == ForEachStatement::ITERATE) {
           ExpressionClassifier classifier(this);
           ParseAssignmentExpression(true, &classifier, CHECK_OK);
           RewriteNonPattern(&classifier, CHECK_OK);
         } else {
           ParseExpression(true, CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
-        Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
+        Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
         {
-          BlockState block_state(&scope_, body_scope);
+          BlockState block_state(&state_, body_scope);
           ParseScopedStatement(true, CHECK_OK);
         }
         return Statement::Default();
       }
     }
   }
 
   // Parsed initializer at this point.
   Expect(Token::SEMICOLON, CHECK_OK);
 
   // 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 (has_lexical) inner_scope = NewScope(for_scope, BLOCK_SCOPE);
 
   {
-    BlockState block_state(&scope_, inner_scope);
+    BlockState block_state(&state_, inner_scope);
 
     if (peek() != Token::SEMICOLON) {
       ParseExpression(true, CHECK_OK);
     }
     Expect(Token::SEMICOLON, CHECK_OK);
 
     if (peek() != Token::RPAREN) {
       ParseExpression(true, CHECK_OK);
     }
     Expect(Token::RPAREN, CHECK_OK);
@@ skipping 44 matching lines @@
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessageAt(scanner()->location(), MessageTemplate::kNoCatchOrFinally);
     *ok = false;
     return Statement::Default();
   }
   TailCallExpressionList tail_call_expressions_in_catch_block(zone());
   bool catch_block_exists = false;
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
     Expect(Token::LPAREN, CHECK_OK);
-    Scope* catch_scope = NewScope(scope_, CATCH_SCOPE);
+    Scope* catch_scope = NewScope(scope(), CATCH_SCOPE);
     ExpressionClassifier pattern_classifier(this);
     ParsePrimaryExpression(&pattern_classifier, CHECK_OK);
     ValidateBindingPattern(&pattern_classifier, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     {
       CollectExpressionsInTailPositionToListScope
           collect_tail_call_expressions_scope(
               function_state_, &tail_call_expressions_in_catch_block);
-      BlockState block_state(&scope_, catch_scope);
-      Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
+      BlockState block_state(&state_, catch_scope);
+      Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
       {
-        BlockState block_state(&scope_, block_scope);
+        BlockState block_state(&state_, block_scope);
         ParseBlock(CHECK_OK);
       }
     }
     catch_block_exists = true;
     tok = peek();
   }
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     ParseBlock(CHECK_OK);
     if (FLAG_harmony_explicit_tailcalls && catch_block_exists &&
@@ skipping 33 matching lines @@
 
 PreParser::Expression PreParser::ParseFunctionLiteral(
     Identifier function_name, Scanner::Location function_name_location,
     FunctionNameValidity function_name_validity, FunctionKind kind,
     int function_token_pos, FunctionLiteral::FunctionType function_type,
     LanguageMode language_mode, bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   // Parse function body.
-  bool outer_is_script_scope = scope_->is_script_scope();
-  Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE, kind);
+  bool outer_is_script_scope = scope()->is_script_scope();
+  Scope* function_scope = NewScope(scope(), FUNCTION_SCOPE, kind);
   function_scope->SetLanguageMode(language_mode);
   PreParserFactory factory(NULL);
-  FunctionState function_state(&function_state_, &scope_, function_scope, kind,
+  FunctionState function_state(&function_state_, &state_, function_scope, kind,
                                &factory);
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   ExpressionClassifier formals_classifier(this, &duplicate_finder);
 
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = scanner()->location().beg_pos;
   function_scope->set_start_position(start_position);
   PreParserFormalParameters formals(function_scope);
   ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
@@ skipping 75 matching lines @@
   ParseStatementList(Token::RBRACE, ok, bookmark);
   if (!*ok) return;
   if (bookmark && bookmark->HasBeenReset()) return;
 
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   log_->LogFunction(body_start, body_end,
                     function_state_->materialized_literal_count(),
                     function_state_->expected_property_count(), language_mode(),
-                    scope_->uses_super_property(), scope_->calls_eval());
+                    scope()->uses_super_property(), scope()->calls_eval());
 }
 
 PreParserExpression PreParser::ParseClassLiteral(
     ExpressionClassifier* classifier, PreParserIdentifier 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 EmptyExpression();
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
     return EmptyExpression();
   }
 
   LanguageMode class_language_mode = language_mode();
-  Scope* scope = NewScope(scope_, BLOCK_SCOPE);
-  BlockState block_state(&scope_, scope);
-  scope_->SetLanguageMode(
+  Scope* scope = NewScope(this->scope(), BLOCK_SCOPE);
+  BlockState block_state(&state_, scope);
+  this->scope()->SetLanguageMode(
       static_cast<LanguageMode>(class_language_mode | STRICT));
   // TODO(marja): Make PreParser use scope names too.
-  // scope_->SetScopeName(name);
+  // this->scope()->SetScopeName(name);
 
   bool has_extends = Check(Token::EXTENDS);
   if (has_extends) {
     ExpressionClassifier extends_classifier(this);
     ParseLeftHandSideExpression(&extends_classifier, CHECK_OK);
     CheckNoTailCallExpressions(&extends_classifier, CHECK_OK);
     ValidateExpression(&extends_classifier, CHECK_OK);
     if (classifier != nullptr) {
       classifier->Accumulate(&extends_classifier,
                              ExpressionClassifier::ExpressionProductions);
@@ skipping 56 matching lines @@
   while (peek() != Token::RBRACE) {
     ParseStatementListItem(CHECK_OK);
   }
   Expect(Token::RBRACE, CHECK_OK);
   return PreParserExpression::Default();
 }
 
 void PreParserTraits::ParseAsyncArrowSingleExpressionBody(
     PreParserStatementList body, bool accept_IN,
     Type::ExpressionClassifier* classifier, int pos, bool* ok) {
-  Scope* scope = pre_parser_->scope_;
+  Scope* scope = pre_parser_->scope();
   scope->ForceContextAllocation();
 
   PreParserExpression return_value =
       pre_parser_->ParseAssignmentExpression(accept_IN, classifier, ok);
   if (!*ok) return;
 
   body->Add(PreParserStatement::ExpressionStatement(return_value), zone());
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8