Follow up to r37787: Put even more AST nodes into local_zone_.

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 3216 matching lines @@
   DebuggerStatement* NewDebuggerStatement(int pos) {
     return new (local_zone_) DebuggerStatement(local_zone_, pos);
   }
 
   EmptyStatement* NewEmptyStatement(int pos) {
     return new (local_zone_) EmptyStatement(local_zone_, pos);
   }
 
   SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(
       Statement* statement, Scope* scope) {
-    return new (parser_zone_)
-        SloppyBlockFunctionStatement(parser_zone_, statement, scope);
+    return new (local_zone_)
+        SloppyBlockFunctionStatement(local_zone_, statement, scope);
   }
 
   CaseClause* NewCaseClause(
       Expression* label, ZoneList<Statement*>* statements, int pos) {
     return new (local_zone_) CaseClause(local_zone_, label, statements, pos);
   }
 
   Literal* NewStringLiteral(const AstRawString* string, int pos) {
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewString(string), pos);
@@ skipping 214 matching lines @@
         function_type, has_duplicate_parameters, eager_compile_hint, kind,
         position, true);
   }
 
   // Creates a FunctionLiteral representing a top-level script, the
   // result of an eval (top-level or otherwise), or the result of calling
   // the Function constructor.
   FunctionLiteral* NewScriptOrEvalFunctionLiteral(
       Scope* scope, ZoneList<Statement*>* body, int materialized_literal_count,
       int expected_property_count) {
-    return new (parser_zone_) FunctionLiteral(
-        parser_zone_, ast_value_factory_->empty_string(), ast_value_factory_,
+    return new (local_zone_) FunctionLiteral(
+        local_zone_, ast_value_factory_->empty_string(), ast_value_factory_,
         scope, body, materialized_literal_count, expected_property_count, 0,
         FunctionLiteral::kAnonymousExpression,
         FunctionLiteral::kNoDuplicateParameters,
         FunctionLiteral::kShouldLazyCompile, FunctionKind::kNormalFunction, 0,
         false);
   }
 
   ClassLiteral* NewClassLiteral(Scope* scope, VariableProxy* proxy,
                                 Expression* extends,
                                 FunctionLiteral* constructor,
                                 ZoneList<ObjectLiteral::Property*>* properties,
                                 int start_position, int end_position) {
-    return new (parser_zone_)
-        ClassLiteral(parser_zone_, scope, proxy, extends, constructor,
+    return new (local_zone_)
+        ClassLiteral(local_zone_, scope, proxy, extends, constructor,
                      properties, start_position, end_position);
   }
 
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
-    return new (parser_zone_)
-        NativeFunctionLiteral(parser_zone_, name, extension, pos);
+    return new (local_zone_)
+        NativeFunctionLiteral(local_zone_, name, extension, pos);
   }
 
   DoExpression* NewDoExpression(Block* block, Variable* result_var, int pos) {
     VariableProxy* result = NewVariableProxy(result_var, pos);
     return new (local_zone_) DoExpression(local_zone_, block, result, pos);
   }
 
   ThisFunction* NewThisFunction(int pos) {
     return new (local_zone_) ThisFunction(local_zone_, pos);
   }
 
   SuperPropertyReference* NewSuperPropertyReference(VariableProxy* this_var,
                                                     Expression* home_object,
                                                     int pos) {
-    return new (parser_zone_)
-        SuperPropertyReference(parser_zone_, this_var, home_object, pos);
+    return new (local_zone_)
+        SuperPropertyReference(local_zone_, this_var, home_object, pos);
   }
 
   SuperCallReference* NewSuperCallReference(VariableProxy* this_var,
                                             VariableProxy* new_target_var,
                                             VariableProxy* this_function_var,
                                             int pos) {
-    return new (parser_zone_) SuperCallReference(
-        parser_zone_, this_var, new_target_var, this_function_var, pos);
+    return new (local_zone_) SuperCallReference(
+        local_zone_, this_var, new_target_var, this_function_var, pos);
   }
 
   EmptyParentheses* NewEmptyParentheses(int pos) {
     return new (local_zone_) EmptyParentheses(local_zone_, pos);
   }
 
   Zone* zone() const { return local_zone_; }
 
   // Handles use of temporary zones when parsing inner function bodies.
   class BodyScope {
@@ skipping 62 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_