Allocate block scopes in block states when possible

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/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 265 matching lines @@
 
   // ---------------------------------------------------------------------------
   // ScopeState and its subclasses implement the parser's scope stack.
   // ScopeState keeps track of the current scope, and the outer ScopeState. The
   // parser's scope_state_ points to the top ScopeState. ScopeState's
   // constructor push on the scope stack and the destructors pop. BlockState and
   // FunctionState are used to hold additional per-block and per-function state.
   class ScopeState BASE_EMBEDDED {
    public:
     V8_INLINE Scope* scope() const { return scope_; }
+    Zone* zone() const { return scope_->zone(); }
 
    protected:
     ScopeState(ScopeState** scope_stack, Scope* scope)
         : scope_stack_(scope_stack), outer_scope_(*scope_stack), scope_(scope) {
       *scope_stack = this;
     }
     ~ScopeState() { *scope_stack_ = outer_scope_; }
 
-    Zone* zone() const { return scope_->zone(); }
-
    private:
-    ScopeState** scope_stack_;
-    ScopeState* outer_scope_;
+    ScopeState** const scope_stack_;
+    ScopeState* const outer_scope_;
     Scope* scope_;
   };
 
   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)) {}
+
+    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* parent = outer_state->scope();
+      Zone* zone = outer_state->zone();
+      return new (zone) Scope(zone, parent, BLOCK_SCOPE, kNormalFunction);
+    }
   };
 
   struct DestructuringAssignment {
    public:
     DestructuringAssignment(ExpressionT expression, Scope* scope)
         : assignment(expression), scope(scope) {}
 
     ExpressionT assignment;
     Scope* scope;
   };
@@ skipping 3337 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H