[es6] parse destructuring assignment

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/bailout-reason.h"
 #include "src/expression-classifier.h"
 #include "src/func-name-inferrer.h"
@@ skipping 70 matching lines @@
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
   typedef typename Traits::Type::FormalParameter FormalParameterT;
   typedef typename Traits::Type::FormalParameters FormalParametersT;
   typedef typename Traits::Type::FunctionLiteral FunctionLiteralT;
   typedef typename Traits::Type::Literal LiteralT;
   typedef typename Traits::Type::ObjectLiteralProperty ObjectLiteralPropertyT;
 
+  enum ExpressionFlavor {
+    VanillaExpression,
+    ElementExpression
+  };
+
   ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
              v8::Extension* extension, AstValueFactory* ast_value_factory,
              ParserRecorder* log, typename Traits::Type::Parser this_object)
       : Traits(this_object),
         parenthesized_function_(false),
+        has_seen_assignment_pattern_(false),
         scope_(NULL),
         function_state_(NULL),
         extension_(extension),
         fni_(NULL),
         ast_value_factory_(ast_value_factory),
         log_(log),
         mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
         stack_limit_(stack_limit),
         zone_(zone),
         scanner_(scanner),
@@ skipping 337 matching lines @@
                          MessageTemplate::Template message, bool* ok) {
     Scanner::Location octal = scanner()->octal_position();
     if (octal.IsValid() && beg_pos <= octal.beg_pos &&
         octal.end_pos <= end_pos) {
       ReportMessageAt(octal, message);
       scanner()->clear_octal_position();
       *ok = false;
     }
   }
 
+  bool CheckAssignmentPattern(ExpressionT value,
+                              ExpressionClassifier* classifier, bool* ok) {
+    if (value->IsPatternOrLiteral()) {
+      if (!classifier->is_valid_assignment_pattern()) {
+        ReportClassifierError(classifier->assignment_pattern_error());
+        *ok = false;
+      }
+      return true;
+    }
+    return false;
+  }
+
   inline void CheckStrictOctalLiteral(int beg_pos, int end_pos, bool* ok) {
     CheckOctalLiteral(beg_pos, end_pos, MessageTemplate::kStrictOctalLiteral,
                       ok);
   }
 
   inline void CheckTemplateOctalLiteral(int beg_pos, int end_pos, bool* ok) {
     CheckOctalLiteral(beg_pos, end_pos, MessageTemplate::kTemplateOctalLiteral,
                       ok);
   }
 
@@ skipping 201 matching lines @@
   ExpressionT ParseObjectLiteral(ExpressionClassifier* classifier, bool* ok);
   ObjectLiteralPropertyT ParsePropertyDefinition(
       ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
       bool is_static, bool* is_computed_name, bool* has_seen_constructor,
       ExpressionClassifier* classifier, bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(
       Scanner::Location* first_spread_pos, ExpressionClassifier* classifier,
       bool* ok);
   ExpressionT ParseAssignmentExpression(bool accept_IN,
                                         ExpressionClassifier* classifier,
-                                        bool* ok);
+                                        ExpressionFlavor flavor, bool* ok);
+  ExpressionT ParseAssignmentExpression(bool accept_IN,
+                                        ExpressionClassifier* classifier,
+                                        bool* ok) {
+    return ParseAssignmentExpression(accept_IN, classifier, VanillaExpression,
+                                     ok);
+  }
+  ExpressionT ParseNestedAssignmentExpression(bool accept_IN,
+                                              ExpressionClassifier* classifier,
+                                              bool* ok) {
+    bool saved = has_seen_assignment_pattern_;
+    has_seen_assignment_pattern_ = false;
+    ExpressionT result = ParseAssignmentExpression(
+        accept_IN, classifier, ok);
+    if (!*ok) return this->EmptyExpression();
+    has_seen_assignment_pattern_ = saved;
+    return result;
+  }
   ExpressionT ParseYieldExpression(ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseConditionalExpression(bool accept_IN,
                                          ExpressionClassifier* classifier,
                                          bool* ok);
   ExpressionT ParseBinaryExpression(int prec, bool accept_IN,
                                     ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseUnaryExpression(ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParsePostfixExpression(ExpressionClassifier* classifier,
                                      bool* ok);
   ExpressionT ParseLeftHandSideExpression(ExpressionClassifier* classifier,
@@ skipping 28 matching lines @@
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression, int beg_pos, int end_pos,
       MessageTemplate::Template message, bool* ok);
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression, int beg_pos, int end_pos,
       MessageTemplate::Template message, ParseErrorType type, bool* ok);
 
+  void CheckPatternElement(
+    ExpressionT expression, int beg_pos, int end_pos,
+    ExpressionClassifier* classifier);
+
   // Used to validate property names in object literals and class literals
   enum PropertyKind {
     kAccessorProperty,
     kValueProperty,
     kMethodProperty
   };
 
   class ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralCheckerBase(ParserBase* parser) : parser_(parser) {}
@@ skipping 44 matching lines @@
     }
 
     bool has_seen_constructor_;
   };
 
   // If true, the next (and immediately following) function literal is
   // preceded by a parenthesis.
   // Heuristically that means that the function will be called immediately,
   // so never lazily compile it.
   bool parenthesized_function_;
+  bool has_seen_assignment_pattern_;
 
   Scope* scope_;                   // Scope stack.
   FunctionState* function_state_;  // Function state stack.
   v8::Extension* extension_;
   FuncNameInferrer* fni_;
   AstValueFactory* ast_value_factory_;  // Not owned.
   ParserRecorder* log_;
   Mode mode_;
   uintptr_t stack_limit_;
 
@@ skipping 101 matching lines @@
   friend class PreParserExpression;
 };
 
 
 class PreParserExpression {
  public:
   static PreParserExpression Default() {
     return PreParserExpression(TypeField::encode(kExpression));
   }
 
+  static PreParserExpression Assignment(PreParserExpression lhs,
+                                        Token::Value op) {
+    uint32_t code = TypeField::encode(kAssignment);
+    if (op == Token::ASSIGN &&
+        (lhs->IsObjectLiteral() || lhs->IsArrayLiteral())) {
+      code |= ExpressionTypeField::encode(kDestructuringAssignment);
+    }
+    return PreParserExpression(code);
+  }
+
   static PreParserExpression Spread(PreParserExpression expression) {
     return PreParserExpression(TypeField::encode(kSpreadExpression));
   }
 
   static PreParserExpression FromIdentifier(PreParserIdentifier id) {
     return PreParserExpression(TypeField::encode(kIdentifierExpression) |
                                IdentifierTypeField::encode(id.type_));
   }
 
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
     return PreParserExpression(TypeField::encode(kBinaryOperationExpression));
   }
 
   static PreParserExpression StringLiteral() {
-    return PreParserExpression(TypeField::encode(kStringLiteralExpression));
+    return PreParserExpression(TypeField::encode(kStringLiteral));
   }
 
   static PreParserExpression UseStrictStringLiteral() {
-    return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
+    return PreParserExpression(TypeField::encode(kStringLiteral) |
                                IsUseStrictField::encode(true));
   }
 
   static PreParserExpression UseStrongStringLiteral() {
-    return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
+    return PreParserExpression(TypeField::encode(kStringLiteral) |
                                IsUseStrongField::encode(true));
   }
 
+  static PreParserExpression NumberLiteral() {
+    return PreParserExpression(TypeField::encode(kNumberLiteral));
+  }
+
+  static PreParserExpression ArrayLiteral() {
+    return PreParserExpression(TypeField::encode(kArrayLiteral));
+  }
+
+  static PreParserExpression ObjectLiteral() {
+    return PreParserExpression(TypeField::encode(kObjectLiteral));
+  }
+
   static PreParserExpression This() {
     return PreParserExpression(TypeField::encode(kExpression) |
                                ExpressionTypeField::encode(kThisExpression));
   }
 
   static PreParserExpression ThisProperty() {
     return PreParserExpression(
         TypeField::encode(kExpression) |
         ExpressionTypeField::encode(kThisPropertyExpression));
   }
@@ skipping 24 matching lines @@
   bool IsIdentifier() const {
     return TypeField::decode(code_) == kIdentifierExpression;
   }
 
   PreParserIdentifier AsIdentifier() const {
     DCHECK(IsIdentifier());
     return PreParserIdentifier(IdentifierTypeField::decode(code_));
   }
 
   bool IsStringLiteral() const {
-    return TypeField::decode(code_) == kStringLiteralExpression;
+    return TypeField::decode(code_) == kStringLiteral;
   }
 
   bool IsUseStrictLiteral() const {
-    return TypeField::decode(code_) == kStringLiteralExpression &&
+    return TypeField::decode(code_) == kStringLiteral &&
            IsUseStrictField::decode(code_);
   }
 
   bool IsUseStrongLiteral() const {
-    return TypeField::decode(code_) == kStringLiteralExpression &&
+    return TypeField::decode(code_) == kStringLiteral &&
            IsUseStrongField::decode(code_);
   }
 
+  bool IsNumberLiteral() const {
+    return TypeField::decode(code_) == kNumberLiteral;
+  }
+
+  bool IsArrayLiteral() const {
+    return TypeField::decode(code_) == kArrayLiteral;
+  }
+
+  bool IsObjectLiteral() const {
+    return TypeField::decode(code_) == kObjectLiteral;
+  }
+
+  inline bool IsPatternOrLiteral() const {
+    return IsObjectLiteral() || IsArrayLiteral();
+  }
+
   bool IsThis() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kThisExpression;
   }
 
   bool IsThisProperty() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kThisPropertyExpression;
   }
 
@@ skipping 19 matching lines @@
 
   // At the moment PreParser doesn't track these expression types.
   bool IsFunctionLiteral() const { return false; }
   bool IsCallNew() const { return false; }
 
   bool IsNoTemplateTag() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kNoTemplateTagExpression;
   }
 
+  bool IsAssignment() const {
+    return TypeField::decode(code_) == kAssignment;
+  }
+
+  PreParserExpression AsAssignment() const { return *this; }
+
+  bool IsDestructuring() const {
+    return TypeField::decode(code_) == kAssignment &&
+           ExpressionTypeField::decode(code_) == kDestructuringAssignment;
+  }
+
   bool IsSpreadExpression() const {
     return TypeField::decode(code_) == kSpreadExpression;
   }
 
   PreParserExpression AsFunctionLiteral() { return *this; }
 
   bool IsBinaryOperation() const {
     return TypeField::decode(code_) == kBinaryOperationExpression;
   }
 
   // Dummy implementation for making expression->somefunc() work in both Parser
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
   void set_should_eager_compile() {}
 
   int position() const { return RelocInfo::kNoPosition; }
   void set_function_token_position(int position) {}
 
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
-    kStringLiteralExpression,
+    kStringLiteral,
+    kNumberLiteral,
+    kArrayLiteral,
+    kObjectLiteral,
     kBinaryOperationExpression,
-    kSpreadExpression
+    kSpreadExpression,
+    kAssignment
   };
 
   enum ExpressionType {
     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kSuperCallReference,
-    kNoTemplateTagExpression
+    kNoTemplateTagExpression,
+    kDestructuringAssignment
   };
 
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
   // The first three bits are for the Type.
-  typedef BitField<Type, 0, 3> TypeField;
+  typedef BitField<Type, 0, 4> TypeField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.
   typedef BitField<ExpressionType, TypeField::kNext, 3> ExpressionTypeField;
   typedef BitField<bool, TypeField::kNext, 1> IsUseStrictField;
   typedef BitField<bool, IsUseStrictField::kNext, 1> IsUseStrongField;
   typedef BitField<PreParserIdentifier::Type, TypeField::kNext, 10>
       IdentifierTypeField;
 
   uint32_t code_;
@@ skipping 83 matching lines @@
 
 
 typedef PreParserList<PreParserStatement> PreParserStatementList;
 
 
 class PreParserFactory {
  public:
   explicit PreParserFactory(void* unused_value_factory) {}
   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
                                        int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::StringLiteral();
   }
   PreParserExpression NewNumberLiteral(double number,
                                        int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::NumberLiteral();
   }
   PreParserExpression NewRegExpLiteral(PreParserIdentifier js_pattern,
                                        PreParserIdentifier js_flags,
                                        int literal_index,
                                        bool is_strong,
                                        int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
                                       int literal_index,
                                       bool is_strong,
                                       int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::ArrayLiteral();
   }
   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
                                       int first_spread_index, int literal_index,
                                       bool is_strong, int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::ArrayLiteral();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
                                                PreParserExpression value,
                                                ObjectLiteralProperty::Kind kind,
                                                bool is_static,
                                                bool is_computed_name) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
                                                PreParserExpression value,
                                                bool is_static,
                                                bool is_computed_name) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteral(PreParserExpressionList properties,
                                        int literal_index,
                                        int boilerplate_properties,
                                        bool has_function,
                                        bool is_strong,
                                        int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::ObjectLiteral();
   }
   PreParserExpression NewVariableProxy(void* variable) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewProperty(PreParserExpression obj,
                                   PreParserExpression key,
                                   int pos) {
     if (obj.IsThis()) {
       return PreParserExpression::ThisProperty();
     }
@@ skipping 11 matching lines @@
   }
   PreParserExpression NewCompareOperation(Token::Value op,
                                           PreParserExpression left,
                                           PreParserExpression right, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewAssignment(Token::Value op,
                                     PreParserExpression left,
                                     PreParserExpression right,
                                     int pos) {
-    return PreParserExpression::Default();
+    return PreParserExpression::Assignment(left, op);
   }
   PreParserExpression NewYield(PreParserExpression generator_object,
                                PreParserExpression expression,
                                Yield::Kind yield_kind,
                                int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewConditional(PreParserExpression condition,
                                      PreParserExpression then_expression,
                                      PreParserExpression else_expression,
@@ skipping 339 matching lines @@
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE void ParseArrowFunctionFormalParameterList(
       PreParserFormalParameters* parameters,
       PreParserExpression expression, const Scanner::Location& params_loc,
       Scanner::Location* duplicate_loc, bool* ok);
 
+  PreParserExpression RewriteDestructuringAssignment(
+        PreParserExpression expression) {
+    return expression;
+  }
+
   void ReindexLiterals(const PreParserFormalParameters& paramaters) {}
 
   struct TemplateLiteralState {};
 
   TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
   }
   void AddTemplateSpan(TemplateLiteralState*, bool) {}
   void AddTemplateExpression(TemplateLiteralState*, PreParserExpression) {}
   PreParserExpression CloseTemplateLiteral(TemplateLiteralState*, int,
@@ skipping 814 matching lines @@
         return this->EmptyExpression();
       }
       elem = this->GetLiteralTheHole(peek_position(), factory());
     } else if (peek() == Token::ELLIPSIS) {
       if (!allow_harmony_spread_arrays()) {
         ExpressionUnexpectedToken(classifier);
       }
       int start_pos = peek_position();
       Consume(Token::ELLIPSIS);
       ExpressionT argument =
-          this->ParseAssignmentExpression(true, classifier, CHECK_OK);
+          this->ParseAssignmentExpression(true, classifier, ElementExpression,
+                                          CHECK_OK);
       elem = factory()->NewSpread(argument, start_pos);
       seen_spread = true;
       if (first_spread_index < 0) {
         first_spread_index = values->length();
       }
     } else {
-      elem = this->ParseAssignmentExpression(true, classifier, CHECK_OK);
+      elem = this->ParseAssignmentExpression(true, classifier,
+                                             ElementExpression, CHECK_OK);
     }
     values->Add(elem, zone_);
     if (peek() != Token::RBRACK) {
       if (seen_spread) {
         BindingPatternUnexpectedToken(classifier);
       }
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RBRACK, CHECK_OK);
@@ skipping 93 matching lines @@
 
   if (!in_class && !is_generator && peek() == Token::COLON) {
     // PropertyDefinition : PropertyName ':' AssignmentExpression
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kValueProperty, is_static,
                              is_generator,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
     Consume(Token::COLON);
     value = this->ParseAssignmentExpression(
-        true, classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+        true, classifier, ElementExpression,
+        CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   } else if (is_generator || peek() == Token::LPAREN) {
     // Concise Method
+    if (!in_class) {
+      classifier->RecordPatternError(
+          Scanner::Location(next_beg_pos, next_end_pos),
+          MessageTemplate::kInvalidDestructuringTarget);
+    }
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kMethodProperty, is_static,
                              is_generator,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
     FunctionKind kind = is_generator ? FunctionKind::kConciseGeneratorMethod
                                      : FunctionKind::kConciseMethod;
 
     if (in_class && !is_static && this->IsConstructor(name)) {
@@ skipping 13 matching lines @@
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
 
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
     return ParsePropertyDefinition(checker, true, has_extends, true,
                                    is_computed_name, nullptr, classifier, ok);
   } else if (is_get || is_set) {
     // Accessor
+    if (!in_class) {
+      classifier->RecordPatternError(
+          Scanner::Location(next_beg_pos, next_end_pos),
+          MessageTemplate::kInvalidDestructuringTarget);
+    }
     name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
     name_expression = ParsePropertyName(
         &name, &dont_care, &dont_care, &dont_care, is_computed_name, classifier,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kAccessorProperty, is_static,
@@ skipping 17 matching lines @@
           factory()->NewStringLiteral(name, name_expression->position());
     }
 
     return factory()->NewObjectLiteralProperty(
         name_expression, value,
         is_get ? ObjectLiteralProperty::GETTER : ObjectLiteralProperty::SETTER,
         is_static, *is_computed_name);
 
   } else if (!in_class && Token::IsIdentifier(name_token, language_mode(),
                                               this->is_generator())) {
+    // IdentifierReference | CoverInitializedName
     DCHECK(!*is_computed_name);
     DCHECK(!is_static);
 
     if (classifier->duplicate_finder() != nullptr &&
         scanner()->FindSymbol(classifier->duplicate_finder(), 1) != 0) {
       classifier->RecordDuplicateFormalParameterError(scanner()->location());
     }
 
     ExpressionT lhs = this->ExpressionFromIdentifier(
         name, next_beg_pos, next_end_pos, scope_, factory());
     if (peek() == Token::ASSIGN) {
+      // TODO(caitp): don't report SyntaxError for CoverInitializedName when
+      // parsing Pattern.
       this->ExpressionUnexpectedToken(classifier);
       Consume(Token::ASSIGN);
       ExpressionClassifier rhs_classifier;
-      ExpressionT rhs = this->ParseAssignmentExpression(
+
+      ExpressionT rhs = this->ParseNestedAssignmentExpression(
           true, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+
       classifier->Accumulate(rhs_classifier,
                              ExpressionClassifier::ExpressionProduction);
       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 77 matching lines @@
   //   '(' (AssignmentExpression)*[','] ')'
 
   Scanner::Location spread_arg = Scanner::Location::invalid();
   typename Traits::Type::ExpressionList result =
       this->NewExpressionList(4, zone_);
   Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   bool done = (peek() == Token::RPAREN);
   bool was_unspread = false;
   int unspread_sequences_count = 0;
   while (!done) {
+    DCHECK_EQ(has_seen_assignment_pattern_, false);
     bool is_spread = allow_harmony_spreadcalls() && (peek() == Token::ELLIPSIS);
     int start_pos = peek_position();
     if (is_spread) Consume(Token::ELLIPSIS);
-
-    ExpressionT argument = this->ParseAssignmentExpression(
+    ExpressionT argument = this->ParseNestedAssignmentExpression(
         true, classifier, CHECK_OK_CUSTOM(NullExpressionList));
     if (is_spread) {
       if (!spread_arg.IsValid()) {
         spread_arg.beg_pos = start_pos;
         spread_arg.end_pos = peek_position();
       }
       argument = factory()->NewSpread(argument, start_pos);
     }
     result->Add(argument, zone_);
 
@@ skipping 32 matching lines @@
   }
 
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
                                               ExpressionClassifier* classifier,
+                                              ExpressionFlavor flavor,
                                               bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
   int lhs_beg_pos = peek_position();
 
   if (peek() == Token::YIELD && is_generator()) {
@@ skipping 23 matching lines @@
     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(
         parameters, arrow_formals_classifier, CHECK_OK);
+    classifier->RecordPatternError(
+        Scanner::Location(lhs_beg_pos, scanner()->location().end_pos),
+        MessageTemplate::kInvalidDestructuringTarget);
     return expression;
   }
 
   // "expression" was not itself an arrow function parameter list, but it might
   // form part of one.  Propagate speculative formal parameter error locations.
   classifier->Accumulate(arrow_formals_classifier,
                          ExpressionClassifier::StandardProductions |
                              ExpressionClassifier::FormalParametersProductions);
 
+  int lhs_end_pos = scanner()->location().end_pos;
   if (!Token::IsAssignmentOp(peek())) {
+    if (flavor == ElementExpression) {
+      CheckPatternElement(expression, lhs_beg_pos, lhs_end_pos, classifier);
+    }
+    ValidateExpression(classifier, CHECK_OK);
+
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
   if (!(allow_harmony_destructuring() || allow_harmony_default_parameters())) {
     BindingPatternUnexpectedToken(classifier);
   }
 
-  expression = this->CheckAndRewriteReferenceExpression(
-      expression, lhs_beg_pos, scanner()->location().end_pos,
-      MessageTemplate::kInvalidLhsInAssignment, CHECK_OK);
-  expression = this->MarkExpressionAsAssigned(expression);
+  // Check that the LHS is a valid AssignmentPattern, or does not appear to be
+  // an ObjectLiteral or ArrayLiteral.
+  bool has_seen_assignment_pattern = has_seen_assignment_pattern_;
 
   Token::Value op = Next();  // Get assignment operator.
+
   if (op != Token::ASSIGN) {
-    classifier->RecordBindingPatternError(scanner()->location(),
-                                          MessageTemplate::kUnexpectedToken,
-                                          Token::String(op));
+    classifier->RecordPatternError(scanner()->location(),
+                                   MessageTemplate::kUnexpectedToken,
+                                   Token::String(op));
   }
+  bool was_pattern = CheckAssignmentPattern(expression, classifier, CHECK_OK);
+  has_seen_assignment_pattern_ |= was_pattern;
+  if (!was_pattern) {
+    expression = this->CheckAndRewriteReferenceExpression(
+        expression, lhs_beg_pos, lhs_end_pos,
+        MessageTemplate::kInvalidLhsInAssignment, CHECK_OK);
+    expression = this->MarkExpressionAsAssigned(expression);
+  }
+
   int pos = position();
 
   ExpressionClassifier rhs_classifier;
   ExpressionT right =
       this->ParseAssignmentExpression(accept_IN, &rhs_classifier, CHECK_OK);
   classifier->Accumulate(rhs_classifier,
                          ExpressionClassifier::ExpressionProduction);
 
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
@@ skipping 14 matching lines @@
          || op == Token::INIT_CONST_LEGACY
          || op == Token::ASSIGN)
         && (!right->IsCall() && !right->IsCallNew())) {
       fni_->Infer();
     } else {
       fni_->RemoveLastFunction();
     }
     fni_->Leave();
   }
 
-  return factory()->NewAssignment(op, expression, right, pos);
+  ExpressionT result = factory()->NewAssignment(op, expression, right, pos);
+
+  if (has_seen_assignment_pattern_ && !has_seen_assignment_pattern) {
+    // Reset flag when assignment assignment chain has ended, and rewrite the
+    // entire chain.
+    has_seen_assignment_pattern_ = false;
+    return Traits::RewriteDestructuringAssignment(result);
+  }
+
+  return result;
 }
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseYieldExpression(ExpressionClassifier* classifier,
                                          bool* ok) {
   // YieldExpression ::
   //   'yield' ([no line terminator] '*'? AssignmentExpression)?
   int pos = peek_position();
   Expect(Token::YIELD, CHECK_OK);
@@ skipping 13 matching lines @@
       case Token::COMMA:
         // The above set of tokens is the complete set of tokens that can appear
         // after an AssignmentExpression, and none of them can start an
         // AssignmentExpression.  This allows us to avoid looking for an RHS for
         // a Yield::kSuspend operation, given only one look-ahead token.
         if (kind == Yield::kSuspend)
           break;
         DCHECK_EQ(Yield::kDelegating, kind);
         // Delegating yields require an RHS; fall through.
       default:
-        expression = ParseAssignmentExpression(false, classifier, CHECK_OK);
+        expression = ParseNestedAssignmentExpression(false, classifier,
+                                                     CHECK_OK);
         break;
     }
   }
   if (kind == Yield::kDelegating) {
     // var iterator = subject[Symbol.iterator]();
     expression = this->GetIterator(expression, factory());
   }
   typename Traits::Type::YieldExpression yield =
       factory()->NewYield(generator_object, expression, kind, pos);
   return yield;
@@ skipping 1013 matching lines @@
     ExpressionT error = this->NewThrowReferenceError(message, pos);
     return factory()->NewProperty(expression, error, pos);
   } else {
     this->ReportMessageAt(location, message, type);
     *ok = false;
     return this->EmptyExpression();
   }
 }
 
 
+template <typename Traits>
+void ParserBase<Traits>::CheckPatternElement(
+    ExpressionT expression, int beg_pos, int end_pos,
+    ExpressionClassifier* classifier) {
+  if (expression->IsPatternOrLiteral() &&
+      (classifier->is_valid_assignment_pattern() ||
+      classifier->is_valid_binding_pattern())) {
+    return;
+  }
+  if (!expression->IsValidReferenceExpression()) {
+    classifier->RecordPatternError(
+        Scanner::Location(beg_pos, end_pos),
+        MessageTemplate::kInvalidDestructuringTarget);
+  }
+}
+
+
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, bool is_static, bool is_generator,
     bool* ok) {
   DCHECK(!is_static);
   DCHECK(!is_generator || type == kMethodProperty);
@@ skipping 40 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H