Reduce the memory footprint of expression classifiers

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 3006 matching lines @@
  private:
   Parser::FunctionState* function_state_;
   bool old_value_;
 };
 
 // Collects all return expressions at tail call position in this scope
 // to a separate list.
 class Parser::CollectExpressionsInTailPositionToListScope {
  public:
   CollectExpressionsInTailPositionToListScope(
-      Parser::FunctionState* function_state, List<Expression*>* list)
+      Parser::FunctionState* function_state, ZoneList<Expression*>* list)
       : function_state_(function_state), list_(list) {
     function_state->expressions_in_tail_position().Swap(list_);
   }
   ~CollectExpressionsInTailPositionToListScope() {
     function_state_->expressions_in_tail_position().Swap(list_);
   }
 
  private:
   Parser::FunctionState* function_state_;
-  List<Expression*>* list_;
+  ZoneList<Expression*>* list_;
 };
 
 TryStatement* Parser::ParseTryStatement(bool* ok) {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
@@ skipping 13 matching lines @@
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessage(MessageTemplate::kNoCatchOrFinally);
     *ok = false;
     return NULL;
   }
 
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
-  List<Expression*> expressions_in_tail_position_in_catch_block;
+  ZoneList<Expression*> expressions_in_tail_position_in_catch_block(0, zone());
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     catch_scope = NewScope(scope_, CATCH_SCOPE);
     catch_scope->set_start_position(scanner()->location().beg_pos);
 
     ExpressionClassifier pattern_classifier(this);
     Expression* pattern = ParsePrimaryExpression(&pattern_classifier, CHECK_OK);
     ValidateBindingPattern(&pattern_classifier, CHECK_OK);
@@ skipping 85 matching lines @@
     try_block = factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
     try_block->statements()->Add(statement, zone());
     catch_block = NULL;  // Clear to indicate it's been handled.
   }
 
   TryStatement* result = NULL;
   if (catch_block != NULL) {
     // For a try-catch construct append return expressions from the catch block
     // to the list of return expressions.
     function_state_->expressions_in_tail_position().AddAll(
-        expressions_in_tail_position_in_catch_block);
+        expressions_in_tail_position_in_catch_block, zone());
 
     DCHECK(finally_block == NULL);
     DCHECK(catch_scope != NULL && catch_variable != NULL);
     result = factory()->NewTryCatchStatement(try_block, catch_scope,
                                              catch_variable, catch_block, pos);
   } else {
     DCHECK(finally_block != NULL);
     result = factory()->NewTryFinallyStatement(try_block, finally_block, pos);
   }
 
@@ skipping 1606 matching lines @@
     result->Set(kFunctionNameAssignmentIndex,
                 factory()->NewExpressionStatement(
                     factory()->NewAssignment(Token::INIT, fproxy,
                                              factory()->NewThisFunction(pos),
                                              RelocInfo::kNoPosition),
                     RelocInfo::kNoPosition));
   }
 
   // ES6 14.6.1 Static Semantics: IsInTailPosition
   // Mark collected return expressions that are in tail call position.
-  const List<Expression*>& expressions_in_tail_position =
+  const ZoneList<Expression*>& expressions_in_tail_position =
       function_state_->expressions_in_tail_position();
   for (int i = 0; i < expressions_in_tail_position.length(); ++i) {
     expressions_in_tail_position[i]->MarkTail();
   }
   return result;
 }
 
 
 PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
     SingletonLogger* logger, Scanner::BookmarkScope* bookmark) {
@@ skipping 719 matching lines @@
   parser_->RewriteDestructuringAssignments();
 }
 
 
 void ParserTraits::RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                      bool* ok) {
   parser_->RewriteNonPattern(classifier, ok);
 }
 
 
+ZoneList<typename ParserTraits::Type::ExpressionClassifier::Error>*
+ParserTraits::GetReportedErrorList() const {
+  return parser_->function_state_->GetReportedErrorList();
+}
+
+
 Zone* ParserTraits::zone() const {
   return parser_->function_state_->scope()->zone();
 }
 
 
 ZoneList<Expression*>* ParserTraits::GetNonPatternList() const {
   return parser_->function_state_->non_patterns_to_rewrite();
 }
 
 
@@ skipping 825 matching lines @@
 
   statements->Add(get_return, zone);
   statements->Add(check_return, zone);
   statements->Add(call_return, zone);
   statements->Add(validate_output, zone);
 }
 
 
 }  // namespace internal
 }  // namespace v8