[destructuring] Implement initializers in patterns.

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 673 matching lines @@
     }
 
     enum TargetProduction {
       ExpressionProduction = 1 << 0,
       BindingPatternProduction = 1 << 1,
       AssignmentPatternProduction = 1 << 2,
       FormalParametersProduction = 1 << 3,
       ArrowFormalParametersProduction = 1 << 4,
       StandardProductions = (ExpressionProduction | BindingPatternProduction |
                              AssignmentPatternProduction),
+      PatternProductions =
+          BindingPatternProduction | AssignmentPatternProduction,
       AllProductions = (StandardProductions | FormalParametersProduction |
-                        ArrowFormalParametersProduction)
+                        ArrowFormalParametersProduction),
     };
 
     void Accumulate(const ExpressionClassifier& inner,
                     unsigned productions = StandardProductions) {
       if (productions & ExpressionProduction && is_valid_expression()) {
         expression_error_ = inner.expression_error_;
       }
       if (productions & BindingPatternProduction &&
           is_valid_binding_pattern()) {
         binding_pattern_error_ = inner.binding_pattern_error_;
@@ skipping 17 matching lines @@
         }
       }
       if (productions & ArrowFormalParametersProduction &&
           is_valid_arrow_formal_parameters()) {
         // The result continues to be a valid arrow formal parameters if the
         // inner expression is a valid binding pattern.
         arrow_formal_parameters_error_ = inner.binding_pattern_error_;
       }
     }
 
+    void AccumulateReclassifyingAsPattern(const ExpressionClassifier& inner) {
+      Accumulate(inner, AllProductions & ~PatternProductions);
+      if (!inner.is_valid_expression()) {
+        if (is_valid_binding_pattern()) {
+          binding_pattern_error_ = inner.expression_error();
+        }
+        if (is_valid_assignment_pattern()) {
+          assignment_pattern_error_ = inner.expression_error();
+        }
+      }
+    }
+
    private:
     Error expression_error_;
     Error binding_pattern_error_;
     Error assignment_pattern_error_;
     Error arrow_formal_parameters_error_;
     Error duplicate_formal_parameter_error_;
     Error strict_mode_formal_parameter_error_;
     Error strong_mode_formal_parameter_error_;
   };
 
@@ skipping 53 matching lines @@
                                 MessageTemplate::kUnexpectedToken,
                                 Token::String(scanner()->current_token()));
         *ok = false;
       }
     } else if (!classifier->is_valid_arrow_formal_parameters()) {
       ReportClassifierError(classifier->arrow_formal_parameters_error());
       *ok = false;
     }
   }
 
+  void ExpressionUnexpectedToken(ExpressionClassifier* classifier) {
+    classifier->RecordExpressionError(scanner()->peek_location(),
+                                      MessageTemplate::kUnexpectedToken,
+                                      Token::String(peek()));
+  }
+
   void BindingPatternUnexpectedToken(ExpressionClassifier* classifier) {
     classifier->RecordBindingPatternError(scanner()->peek_location(),
                                           MessageTemplate::kUnexpectedToken,
                                           Token::String(peek()));
   }
 
   void ArrowFormalParametersUnexpectedToken(ExpressionClassifier* classifier) {
     classifier->RecordArrowFormalParametersError(
         scanner()->peek_location(), MessageTemplate::kUnexpectedToken,
         Token::String(peek()));
@@ skipping 1854 matching lines @@
     return factory()->NewObjectLiteralProperty(
         name_expression, value,
         is_get ? ObjectLiteralProperty::GETTER : ObjectLiteralProperty::SETTER,
         is_static, *is_computed_name);
 
   } else if (!in_class && allow_harmony_object_literals_ &&
              Token::IsIdentifier(name_token, language_mode(),
                                  this->is_generator())) {
     DCHECK(!*is_computed_name);
     DCHECK(!is_static);
-    value = this->ExpressionFromIdentifier(name, next_beg_pos, next_end_pos,
-                                           scope_, factory());
+
+    ExpressionT lhs = this->ExpressionFromIdentifier(
+        name, next_beg_pos, next_end_pos, scope_, factory());
+    if (peek() == Token::ASSIGN) {
+      this->ExpressionUnexpectedToken(classifier);
+      Consume(Token::ASSIGN);
+      ExpressionClassifier rhs_classifier;
+      ExpressionT rhs = this->ParseAssignmentExpression(
+          true, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+      classifier->AccumulateReclassifyingAsPattern(rhs_classifier);
+      value = factory()->NewAssignment(Token::ASSIGN, lhs, rhs,
+                                       RelocInfo::kNoPosition);
+    } else {
+      value = lhs;
+    }
     return factory()->NewObjectLiteralProperty(
         name_expression, value, ObjectLiteralProperty::COMPUTED, false, false);
 
   } else {
     Token::Value next = Next();
     ReportUnexpectedToken(next);
     *ok = false;
     return this->EmptyObjectLiteralProperty();
   }
 
@@ skipping 201 matching lines @@
   if (!allow_harmony_destructuring()) {
     BindingPatternUnexpectedToken(classifier);
   }
 
   expression = this->CheckAndRewriteReferenceExpression(
       expression, lhs_location, MessageTemplate::kInvalidLhsInAssignment,
       CHECK_OK);
   expression = this->MarkExpressionAsAssigned(expression);
 
   Token::Value op = Next();  // Get assignment operator.
+  if (op != Token::ASSIGN) {
+    classifier->RecordBindingPatternError(scanner()->location(),
+                                          MessageTemplate::kUnexpectedToken,
+                                          Token::String(op));
+  }
   int pos = position();
+
+  ExpressionClassifier rhs_classifier;
   ExpressionT right =
-      this->ParseAssignmentExpression(accept_IN, classifier, CHECK_OK);
+      this->ParseAssignmentExpression(accept_IN, &rhs_classifier, CHECK_OK);
+  classifier->AccumulateReclassifyingAsPattern(rhs_classifier);
 
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
   // assignment to a property of 'this'. We should probably only add
   // properties if we haven't seen them before. Otherwise we'll
   // probably overestimate the number of properties.
   if (op == Token::ASSIGN && this->IsThisProperty(expression)) {
     function_state_->AddProperty();
   }
 
@@ skipping 1048 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H