Don't use different function scopes when parsing with temp zones

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 276 matching lines @@
 
   class BlockState final : public ScopeState {
    public:
     BlockState(ScopeState** scope_stack, Scope* scope)
         : ScopeState(scope_stack, scope) {}
 
     // BlockState(ScopeState**) automatically manages Scope(BLOCK_SCOPE)
     // allocation.
     // TODO(verwaest): Move to LazyBlockState class that only allocates the
     // scope when needed.
-    explicit BlockState(ScopeState** scope_stack)
-        : ScopeState(scope_stack, NewScope(*scope_stack)) {}
+    explicit BlockState(Zone* zone, ScopeState** scope_stack)
+        : ScopeState(scope_stack, NewScope(zone, *scope_stack)) {}
 
     void SetNonlinear() { this->scope()->SetNonlinear(); }
     void set_start_position(int pos) { this->scope()->set_start_position(pos); }
     void set_end_position(int pos) { this->scope()->set_end_position(pos); }
     void set_is_hidden() { this->scope()->set_is_hidden(); }
     Scope* FinalizedBlockScope() const {
       return this->scope()->FinalizeBlockScope();
     }
     LanguageMode language_mode() const {
       return this->scope()->language_mode();
     }
 
    private:
-    Scope* NewScope(ScopeState* outer_state) {
+    Scope* NewScope(Zone* zone, ScopeState* outer_state) {
       Scope* parent = outer_state->scope();
-      Zone* zone = outer_state->zone();
       return new (zone) Scope(zone, parent, BLOCK_SCOPE);
     }
   };
 
   struct DestructuringAssignment {
    public:
     DestructuringAssignment(ExpressionT expression, Scope* scope)
         : assignment(expression), scope(scope) {}
 
     ExpressionT assignment;
@@ skipping 3509 matching lines @@
            formal_parameters.scope
                ->AllowsLazyParsingWithoutUnresolvedVariables());
       // TODO(marja): consider lazy-parsing inner arrow functions too. is_this
       // handling in Scope::ResolveVariable needs to change.
       if (is_lazily_parsed) {
         Scanner::BookmarkScope bookmark(scanner());
         bookmark.Set();
         LazyParsingResult result = impl()->SkipLazyFunctionBody(
             &materialized_literal_count, &expected_property_count, false, true,
             CHECK_OK);
+        formal_parameters.scope->ResetAfterPreparsing(result ==
+                                                      kLazyParsingAborted);
 
         if (formal_parameters.materialized_literals_count > 0) {
           materialized_literal_count +=
               formal_parameters.materialized_literals_count;
         }
 
         if (result == kLazyParsingAborted) {
           bookmark.Apply();
           // Trigger eager (re-)parsing, just below this block.
           is_lazily_parsed = false;
@@ skipping 569 matching lines @@
     ZoneList<const AstRawString*>* labels, bool* ok) {
   // Block ::
   //   '{' StatementList '}'
 
   // Construct block expecting 16 statements.
   BlockT body = factory()->NewBlock(labels, 16, false, kNoSourcePosition);
 
   // Parse the statements and collect escaping labels.
   Expect(Token::LBRACE, CHECK_OK_CUSTOM(NullBlock));
   {
-    BlockState block_state(&scope_state_);
+    BlockState block_state(zone(), &scope_state_);
     block_state.set_start_position(scanner()->location().beg_pos);
     typename Types::Target target(this, body);
 
     while (peek() != Token::RBRACE) {
       StatementT stat = ParseStatementListItem(CHECK_OK_CUSTOM(NullBlock));
       if (!impl()->IsNullStatement(stat) && !impl()->IsEmptyStatement(stat)) {
         body->statements()->Add(stat, zone());
       }
     }
 
     Expect(Token::RBRACE, CHECK_OK_CUSTOM(NullBlock));
     block_state.set_end_position(scanner()->location().end_pos);
     body->set_scope(block_state.FinalizedBlockScope());
   }
   return body;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseScopedStatement(
     ZoneList<const AstRawString*>* labels, bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
     return ParseStatement(labels, kDisallowLabelledFunctionStatement, ok);
   } else {
     if (legacy) {
       impl()->CountUsage(v8::Isolate::kLegacyFunctionDeclaration);
     }
     // Make a block around the statement for a lexical binding
     // is introduced by a FunctionDeclaration.
-    BlockState block_state(&scope_state_);
+    BlockState block_state(zone(), &scope_state_);
     block_state.set_start_position(scanner()->location().beg_pos);
     BlockT block = factory()->NewBlock(NULL, 1, false, kNoSourcePosition);
     StatementT body = impl()->ParseFunctionDeclaration(CHECK_OK);
     block->statements()->Add(body, zone());
     block_state.set_end_position(scanner()->location().end_pos);
     block->set_scope(block_state.FinalizedBlockScope());
     return block;
   }
 }
 
@@ skipping 350 matching lines @@
   int switch_pos = peek_position();
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ExpressionT tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   auto switch_statement = factory()->NewSwitchStatement(labels, switch_pos);
 
   {
-    BlockState cases_block_state(&scope_state_);
+    BlockState cases_block_state(zone(), &scope_state_);
     cases_block_state.set_start_position(scanner()->location().beg_pos);
     cases_block_state.SetNonlinear();
     typename Types::Target target(this, switch_statement);
 
     bool default_seen = false;
     auto cases = impl()->NewCaseClauseList(4);
     Expect(Token::LBRACE, CHECK_OK);
     while (peek() != Token::RBRACE) {
       // An empty label indicates the default case.
       ExpressionT label = impl()->EmptyExpression();
@@ skipping 70 matching lines @@
       CollectExpressionsInTailPositionToListScope
           collect_tail_call_expressions_scope(
               function_state_, &catch_info.tail_call_expressions);
       BlockState catch_block_state(&scope_state_, catch_info.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.
       {
-        BlockState catch_variable_block_state(&scope_state_);
+        BlockState catch_variable_block_state(zone(), &scope_state_);
         catch_variable_block_state.set_start_position(
             scanner()->location().beg_pos);
         typename Types::Target target(this, catch_block);
 
         // This does not simply call ParsePrimaryExpression to avoid
         // ExpressionFromIdentifier from being called in the first
         // branch, which would introduce an unresolved symbol and mess
         // with arrow function names.
         if (peek_any_identifier()) {
           catch_info.name =
@@ skipping 34 matching lines @@
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForStatement(
     ZoneList<const AstRawString*>* labels, bool* ok) {
   int stmt_pos = peek_position();
   ForInfo for_info(this);
   bool bound_names_are_lexical = false;
 
   // Create an in-between scope for let-bound iteration variables.
-  BlockState for_state(&scope_state_);
+  BlockState for_state(zone(), &scope_state_);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_state.set_start_position(scanner()->location().beg_pos);
   for_state.set_is_hidden();
 
   StatementT init = impl()->NullStatement();
   if (peek() != Token::SEMICOLON) {
     // An initializer is present.
     if (peek() == Token::VAR || peek() == Token::CONST ||
         (peek() == Token::LET && IsNextLetKeyword())) {
@@ skipping 50 matching lines @@
         } else {
           enumerable = ParseExpression(true, CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
 
         StatementT final_loop = impl()->NullStatement();
         {
           ReturnExprScope no_tail_calls(function_state_,
                                         ReturnExprContext::kInsideForInOfBody);
-          BlockState block_state(&scope_state_);
+          BlockState block_state(zone(), &scope_state_);
           block_state.set_start_position(scanner()->location().beg_pos);
 
           StatementT body = ParseScopedStatement(nullptr, true, CHECK_OK);
 
           BlockT body_block = impl()->NullBlock();
           ExpressionT each_variable = impl()->EmptyExpression();
           impl()->DesugarBindingInForEachStatement(&for_info, &body_block,
                                                    &each_variable, CHECK_OK);
           body_block->statements()->Add(body, zone());
           final_loop = impl()->InitializeForEachStatement(
@@ skipping 62 matching lines @@
           impl()->RewriteNonPattern(CHECK_OK);
         } else {
           enumerable = ParseExpression(true, CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
 
         {
           ReturnExprScope no_tail_calls(function_state_,
                                         ReturnExprContext::kInsideForInOfBody);
-          BlockState block_state(&scope_state_);
+          BlockState block_state(zone(), &scope_state_);
           block_state.set_start_position(scanner()->location().beg_pos);
 
           // For legacy compat reasons, give for loops similar treatment to
           // if statements in allowing a function declaration for a body
           StatementT body = ParseScopedStatement(nullptr, true, CHECK_OK);
           block_state.set_end_position(scanner()->location().end_pos);
           StatementT final_loop = impl()->InitializeForEachStatement(
               loop, expression, enumerable, body, each_keyword_pos);
 
           Scope* for_scope = for_state.FinalizedBlockScope();
@@ skipping 139 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H