Reduce the memory footprint of expression classifiers

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/hashmap.h"
@@ skipping 220 matching lines @@
       DCHECK(is_generator());
       generator_object_variable_ = variable;
     }
     typename Traits::Type::GeneratorVariable* generator_object_variable()
         const {
       return generator_object_variable_;
     }
 
     typename Traits::Type::Factory* factory() { return factory_; }
 
-    const List<DestructuringAssignment>& destructuring_assignments_to_rewrite()
-        const {
+    const ZoneList<DestructuringAssignment>&
+        destructuring_assignments_to_rewrite() const {
       return destructuring_assignments_to_rewrite_;
     }
 
-    List<ExpressionT>& expressions_in_tail_position() {
+    ZoneList<typename ExpressionClassifier::Error>* GetReportedErrorList() {
+      return &reported_errors_;
+    }
+
+    ZoneList<ExpressionT>& expressions_in_tail_position() {
       return expressions_in_tail_position_;
     }
     void AddExpressionInTailPosition(ExpressionT expression) {
       if (collect_expressions_in_tail_position_) {
-        expressions_in_tail_position_.Add(expression);
+        expressions_in_tail_position_.Add(expression, scope()->zone());
       }
     }
 
     bool collect_expressions_in_tail_position() const {
       return collect_expressions_in_tail_position_;
     }
     void set_collect_expressions_in_tail_position(bool collect) {
       collect_expressions_in_tail_position_ = collect;
     }
 
     ZoneList<ExpressionT>* non_patterns_to_rewrite() {
       return &non_patterns_to_rewrite_;
     }
 
    private:
     void AddDestructuringAssignment(DestructuringAssignment pair) {
-      destructuring_assignments_to_rewrite_.Add(pair);
+      destructuring_assignments_to_rewrite_.Add(pair, scope()->zone());
     }
 
     V8_INLINE Scope* scope() { return *scope_stack_; }
 
     void AddNonPatternForRewriting(ExpressionT expr) {
-      non_patterns_to_rewrite_.Add(expr, (*scope_stack_)->zone());
+      non_patterns_to_rewrite_.Add(expr, scope()->zone());
     }
 
     // Used to assign an index to each literal that needs materialization in
     // the function.  Includes regexp literals, and boilerplate for object and
     // array literals.
     int next_materialized_literal_index_;
 
     // Properties count estimation.
     int expected_property_count_;
 
@@ skipping 10 matching lines @@
     // For generators, this variable may hold the generator object. It variable
     // is used by yield expressions and return statements. It is not necessary
     // for generator functions to have this variable set.
     Variable* generator_object_variable_;
 
     FunctionState** function_state_stack_;
     FunctionState* outer_function_state_;
     Scope** scope_stack_;
     Scope* outer_scope_;
 
-    List<DestructuringAssignment> destructuring_assignments_to_rewrite_;
-    List<ExpressionT> expressions_in_tail_position_;
+    ZoneList<DestructuringAssignment> destructuring_assignments_to_rewrite_;
+    ZoneList<ExpressionT> non_patterns_to_rewrite_;
+    ZoneList<typename ExpressionClassifier::Error> reported_errors_;
+    ZoneList<ExpressionT> expressions_in_tail_position_;
     bool collect_expressions_in_tail_position_;
-    ZoneList<ExpressionT> non_patterns_to_rewrite_;
 
     typename Traits::Type::Factory* factory_;
 
     friend class ParserTraits;
     friend class PreParserTraits;
     friend class Checkpoint;
   };
 
   // Annoyingly, arrow functions first parse as comma expressions, then when we
   // see the => we have to go back and reinterpret the arguments as being formal
@@ skipping 641 matching lines @@
       expected_property_count_(0),
       this_location_(Scanner::Location::invalid()),
       return_location_(Scanner::Location::invalid()),
       super_location_(Scanner::Location::invalid()),
       kind_(kind),
       generator_object_variable_(NULL),
       function_state_stack_(function_state_stack),
       outer_function_state_(*function_state_stack),
       scope_stack_(scope_stack),
       outer_scope_(*scope_stack),
+      destructuring_assignments_to_rewrite_(16, scope->zone()),
+      non_patterns_to_rewrite_(0, scope->zone()),
+      reported_errors_(16, scope->zone()),
+      expressions_in_tail_position_(4, scope->zone()),
       collect_expressions_in_tail_position_(true),
-      non_patterns_to_rewrite_(0, scope->zone()),
       factory_(factory) {
   *scope_stack_ = scope;
   *function_state_stack = this;
 }
 
 
 template <class Traits>
 ParserBase<Traits>::FunctionState::~FunctionState() {
   *scope_stack_ = outer_scope_;
   *function_state_stack_ = outer_function_state_;
@@ skipping 477 matching lines @@
     if (peek() == Token::ELLIPSIS) {
       // 'x, y, ...z' in CoverParenthesizedExpressionAndArrowParameterList only
       // as the formal parameters of'(x, y, ...z) => foo', and is not itself a
       // valid expression or binding pattern.
       ExpressionUnexpectedToken(classifier);
       BindingPatternUnexpectedToken(classifier);
       Consume(Token::ELLIPSIS);
       seen_rest = is_rest = true;
     }
     int pos = position(), expr_pos = peek_position();
+    ExpressionClassifier binding_classifier(this);
     ExpressionT right = this->ParseAssignmentExpression(
         accept_IN, &binding_classifier, CHECK_OK);
     classifier->Accumulate(&binding_classifier,
                            ExpressionClassifier::AllProductions);
     if (is_rest) {
       if (!this->IsIdentifier(right) && !IsValidPattern(right)) {
         classifier->RecordArrowFormalParametersError(
             Scanner::Location(pos, scanner()->location().end_pos),
             MessageTemplate::kInvalidRestParameter);
       }
@@ skipping 492 matching lines @@
   ParserBase<Traits>::Checkpoint checkpoint(this);
   ExpressionClassifier arrow_formals_classifier(this,
                                                 classifier->duplicate_finder());
   bool parenthesized_formals = peek() == Token::LPAREN;
   if (!parenthesized_formals) {
     ArrowFormalParametersUnexpectedToken(&arrow_formals_classifier);
   }
   ExpressionT expression = this->ParseConditionalExpression(
       accept_IN, &arrow_formals_classifier, CHECK_OK);
   if (peek() == Token::ARROW) {
-    classifier->RecordPatternError(scanner()->peek_location(),
-                                   MessageTemplate::kUnexpectedToken,
-                                   Token::String(Token::ARROW));
+    typename ExpressionClassifier::Error e1 =
+        ExpressionClassifier::BindingPatternError(

[caitp (gmail), 2016/02/18 17:04:09]

A thought I had on this duplication:

A BindingPattern is never valid if an AssignmentPattern is invalid, but the
inverse is not always true --- maybe we could use one for "general pattern
errors", and a secondary version for binding patterns specifically --- this
would avoid allocating an extra error for all these (numerous) duplicated cases.

Validating a binding pattern would then perform the act of validating both
GeneralPattern and BindingPattern errors, since binding patterns are more strict
in a few places.

[nickie, 2016/02/19 08:56:31]

I'm sorry, I'm not confident enough to talk about the logic of this.  This is
semantically equivalent to how it was before.  If it can be further simplified,
then by all means I agree.

+            scanner()->peek_location(), MessageTemplate::kUnexpectedToken,
+            Token::String(Token::ARROW));
+    typename ExpressionClassifier::Error e2 =
+        ExpressionClassifier::AssignmentPatternError(
+            scanner()->peek_location(), MessageTemplate::kUnexpectedToken,
+            Token::String(Token::ARROW));
     ValidateArrowFormalParameters(&arrow_formals_classifier, expression,
                                   parenthesized_formals, CHECK_OK);
     Scanner::Location loc(lhs_beg_pos, scanner()->location().end_pos);
     Scope* scope =
         this->NewScope(scope_, FUNCTION_SCOPE, FunctionKind::kArrowFunction);
     // Because the arrow's parameters were parsed in the outer scope, any
     // usage flags that might have been triggered there need to be copied
     // to the arrow scope.
     scope_->PropagateUsageFlagsToScope(scope);
     FormalParametersT parameters(scope);
     if (!arrow_formals_classifier.is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
       parameters.is_simple = false;
     }
 
     checkpoint.Restore(&parameters.materialized_literals_count);
 
     scope->set_start_position(lhs_beg_pos);
     Scanner::Location duplicate_loc = Scanner::Location::invalid();
     this->ParseArrowFunctionFormalParameterList(&parameters, expression, loc,
                                                 &duplicate_loc, CHECK_OK);
     if (duplicate_loc.IsValid()) {
       arrow_formals_classifier.RecordDuplicateFormalParameterError(
           duplicate_loc);
     }
     expression = this->ParseArrowFunctionLiteral(
         accept_IN, parameters, arrow_formals_classifier, CHECK_OK);
+    arrow_formals_classifier.Discard();
+    classifier->RecordBindingPatternError(e1);
+    classifier->RecordAssignmentPatternError(e2);
 
     if (fni_ != nullptr) fni_->Infer();
 
     return expression;
   }
 
   if (this->IsValidReferenceExpression(expression)) {
     arrow_formals_classifier.ForgiveAssignmentPatternError();
   }
 
@@ skipping 1341 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H