[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/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 552 matching lines @@
             message(MessageTemplate::kNone),
             arg(nullptr) {}
 
       Scanner::Location location;
       MessageTemplate::Template message;
       const char* arg;
 
       bool HasError() const { return location.IsValid(); }
     };
 
-    ExpressionClassifier() {}
+    ExpressionClassifier() : lhs_type_(TARGET_NONE), assigned_(false) {}
+
+    enum AssignmentTargetType {
+      TARGET_NONE = 0,
+
+      // IdentifierReference
+      TARGET_IDENTIFIER,
+
+      // MemberExpression . <property name>
+      // MemberExpression [<property name>]
+      TARGET_PROPERTY,
+
+      // MemberExpression ( arguments )
+      // new MemberExpression ( arguments )
+      // MemberExpression TemplateLiteral
+      TARGET_CALL,
+
+      // this
+      // Literal
+      // ArrayLiteral
+      // ObjectLiteral
+      // FunctionExpression
+      // ClassExpression
+      // GeneratorExpression
+      // RegularExpressionLiteral
+      // TemplateLiteral
+      // CoverParenthesizedExpressionAndArrowParameterList
+      TARGET_PRIMARY,
+
+      // new.target
+      // yield (in generator)
+      TARGET_RESTRICTED,
+
+      // UnaryExpression
+      // MultiplicativeExpression
+      // AdditiveExpression
+      // ShiftExpression
+      // RelationalExpression
+      // EqualityExpression
+      // BitwiseANDExpression
+      // BitwiseXORExpression
+      // BitwiseORExpression
+      // LogicalANDExpression
+      // LogicalORExpression
+      // ConditionalExpression
+      // AssignmentExpression
+      // ... Pretty much any binary operator
+      UNACCEPTABLE_TARGET,
+
+      // BindingPattern
+      TARGET_PATTERN
+    };
+
+    inline AssignmentTargetType AssignmentTarget() const { return lhs_type_; }
+
+    inline void AppendAssignmentTarget(AssignmentTargetType type) {
+      if (lhs_type_ == UNACCEPTABLE_TARGET) return;
+      lhs_type_ = type;
+    }
+
+    inline void ReportInvalidSimpleAssignmentTarget() {
+      lhs_type_ = UNACCEPTABLE_TARGET;
+    }
+
+    inline bool IsValidSimpleAssignmentTarget() const {
+      // Only identifiers and properties are valid targets.
+      return lhs_type_ >= TARGET_IDENTIFIER && lhs_type_ <= TARGET_PROPERTY;
+    }
+
+    inline bool IsPatternAssignmentElement() const {
+      // Any AssignmentElement for which IsValidSimpleAssignmentTarget is false.
+      // Used for nested AssignmentPatterns
+      return lhs_type_ == TARGET_PATTERN && is_valid_assignment_pattern();
+    }
+
+    void set_assigned() { assigned_ = true; }
+
+    bool is_destructuring_assignment() const {
+      return lhs_type_ == TARGET_PATTERN && assigned_;
+    }
 
     bool is_valid_expression() const { return !expression_error_.HasError(); }
 
     bool is_valid_binding_pattern() const {
       return !binding_pattern_error_.HasError();
     }
 
     bool is_valid_assignment_pattern() const {
       return !assignment_pattern_error_.HasError();
     }
@@ skipping 116 matching lines @@
       FormalParametersProduction = 1 << 3,
       ArrowFormalParametersProduction = 1 << 4,
       StandardProductions = (ExpressionProduction | BindingPatternProduction |
                              AssignmentPatternProduction),
       PatternProductions =
           BindingPatternProduction | AssignmentPatternProduction,
       AllProductions = (StandardProductions | FormalParametersProduction |
                         ArrowFormalParametersProduction),
     };
 
+    void AccumulateValidSimpleAssignmentTarget(
+        const ExpressionClassifier& inner) {
+      if (lhs_type_ != UNACCEPTABLE_TARGET) {
+        lhs_type_ = inner.lhs_type_;
+      }
+    }
+
     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_;
       }
       if (productions & AssignmentPatternProduction &&
@@ skipping 28 matching lines @@
         if (is_valid_binding_pattern()) {
           binding_pattern_error_ = inner.expression_error();
         }
         if (is_valid_assignment_pattern()) {
           assignment_pattern_error_ = inner.expression_error();
         }
       }
     }
 
    private:
+    AssignmentTargetType lhs_type_;
+    bool assigned_;
     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_;
   };
 
+  ExpressionT CheckDestructuringAssignment(ExpressionT expr,
+                                           ExpressionClassifier* classifier,
+                                           bool* ok) {
+    if (classifier->is_destructuring_assignment()) {
+      if (!classifier->is_valid_assignment_pattern()) {
+        this->ReportClassifierError(classifier->assignment_pattern_error());
+        *ok = false;
+        return this->EmptyExpression();
+      }
+      return Traits::RewriteDestructuringAssignment(expr);
+    }
+    return expr;
+  }
+
   void ReportClassifierError(
       const typename ExpressionClassifier::Error& error) {
     Traits::ReportMessageAt(error.location, error.message, error.arg,
                             kSyntaxError);
   }
 
   void ValidateExpression(const ExpressionClassifier* classifier, bool* ok) {
     if (!classifier->is_valid_expression()) {
       ReportClassifierError(classifier->expression_error());
       *ok = false;
@@ skipping 101 matching lines @@
                                 bool* is_static, bool* is_computed_name,
                                 ExpressionClassifier* classifier, bool* ok);
   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);
+  // TODO(caitp): Use enums for accept_IN / pattern_lhs?
+  ExpressionT ParseAssignmentExpression(bool accept_IN, bool pattern_lhs,
+                                        ExpressionClassifier* classifier,
+                                        bool* ok);
   ExpressionT ParseAssignmentExpression(bool accept_IN,
                                         ExpressionClassifier* classifier,
-                                        bool* ok);
+                                        bool* ok) {
+    return ParseAssignmentExpression(accept_IN, false, classifier, ok);
+  }
   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 932 matching lines @@
 
   inline void MaterializeUnspreadArgumentsLiterals(int count);
 
   inline PreParserExpression SpreadCall(PreParserExpression function,
                                         PreParserExpressionList args, int pos);
 
   inline PreParserExpression SpreadCallNew(PreParserExpression function,
                                            PreParserExpressionList args,
                                            int pos);
 
+  inline PreParserExpression RewriteDestructuringAssignment(
+      PreParserExpression expr) {
+    return expr;
+  }
+
  private:
   PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
 // The PreParser checks that the syntax follows the grammar for JavaScript,
@@ skipping 457 matching lines @@
   //   ObjectLiteral
   //   RegExpLiteral
   //   ClassLiteral
   //   '(' Expression ')'
   //   TemplateLiteral
 
   int beg_pos = scanner()->peek_location().beg_pos;
   int end_pos = scanner()->peek_location().end_pos;
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
+  typename ExpressionClassifier::AssignmentTargetType lhs_part =
+      ExpressionClassifier::TARGET_PRIMARY;
   switch (token) {
     case Token::THIS: {
       BindingPatternUnexpectedToken(classifier);
       Consume(Token::THIS);
       if (is_strong(language_mode())) {
         // Constructors' usages of 'this' in strong mode are parsed separately.
         // TODO(rossberg): this does not work with arrow functions yet.
         if (i::IsConstructor(function_state_->kind())) {
           ReportMessage(MessageTemplate::kStrongConstructorThis);
           *ok = false;
@@ skipping 20 matching lines @@
       result =
           this->ExpressionFromLiteral(token, beg_pos, scanner(), factory());
       break;
 
     case Token::IDENTIFIER:
     case Token::LET:
     case Token::STATIC:
     case Token::YIELD:
     case Token::FUTURE_STRICT_RESERVED_WORD: {
       // Using eval or arguments in this context is OK even in strict mode.
+      lhs_part = ExpressionClassifier::TARGET_IDENTIFIER;
       IdentifierT name = ParseAndClassifyIdentifier(classifier, CHECK_OK);
       result = this->ExpressionFromIdentifier(name, beg_pos, end_pos, scope_,
                                               factory());
       break;
     }
 
     case Token::STRING: {
       classifier->RecordBindingPatternError(
           scanner()->location(), MessageTemplate::kUnexpectedTokenString);
       Consume(Token::STRING);
@@ skipping 43 matching lines @@
             this->NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
         scope->set_start_position(beg_pos);
         ExpressionClassifier args_classifier;
         bool has_rest = false;
         result = this->ParseArrowFunctionLiteral(scope, has_rest,
                                                  args_classifier, CHECK_OK);
       } else {
         // Heuristically try to detect immediately called functions before
         // seeing the call parentheses.
         parenthesized_function_ = (peek() == Token::FUNCTION);
-        result = this->ParseExpression(true, classifier, CHECK_OK);
+        ExpressionClassifier expr_classifier;
+        result = this->ParseExpression(true, &expr_classifier, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
+        if (peek() == Token::ARROW || parenthesized_function_) {
+          classifier->Accumulate(
+              expr_classifier,
+              ExpressionClassifier::ArrowFormalParametersProduction |
+                  ExpressionClassifier::FormalParametersProduction);
+        } else {
+          lhs_part = expr_classifier.AssignmentTarget();
+        }
       }
       break;
 
     case Token::CLASS: {
       BindingPatternUnexpectedToken(classifier);
       Consume(Token::CLASS);
       if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
         ReportMessage(MessageTemplate::kSloppyLexical);
         *ok = false;
         break;
@@ skipping 15 matching lines @@
 
     case Token::TEMPLATE_SPAN:
     case Token::TEMPLATE_TAIL:
       result = this->ParseTemplateLiteral(Traits::NoTemplateTag(), beg_pos,
                                           classifier, CHECK_OK);
       break;
 
     case Token::MOD:
       if (allow_natives() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
+        lhs_part = ExpressionClassifier::TARGET_CALL;
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
     default: {
       Next();
       ReportUnexpectedToken(token);
       *ok = false;
     }
   }
 
+  if (*ok && lhs_part != ExpressionClassifier::TARGET_NONE) {
+    classifier->AppendAssignmentTarget(lhs_part);
+  }
+
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
     bool accept_IN, bool* ok) {
   ExpressionClassifier classifier;
   ExpressionT result = ParseExpression(accept_IN, &classifier, CHECK_OK);
   ValidateExpression(&classifier, CHECK_OK);
   return result;
 }
 
 
 // Precedence = 1
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseExpression(
     bool accept_IN, ExpressionClassifier* classifier, bool* ok) {
   // Expression ::
   //   AssignmentExpression
   //   Expression ',' AssignmentExpression
 
-  ExpressionClassifier binding_classifier;
+  ExpressionClassifier expr_classifier;
   ExpressionT result =
-      this->ParseAssignmentExpression(accept_IN, &binding_classifier, CHECK_OK);
-  classifier->Accumulate(binding_classifier,
-                         ExpressionClassifier::AllProductions);
+      this->ParseAssignmentExpression(accept_IN, &expr_classifier, CHECK_OK);
+  classifier->AccumulateValidSimpleAssignmentTarget(expr_classifier);
+  classifier->Accumulate(expr_classifier,
+                         expr_classifier.is_destructuring_assignment()
+                             ? ExpressionClassifier::PatternProductions
+                             : ExpressionClassifier::AllProductions);
   while (peek() == Token::COMMA) {
     Expect(Token::COMMA, CHECK_OK);
     int pos = position();
-    ExpressionT right = this->ParseAssignmentExpression(
-        accept_IN, &binding_classifier, CHECK_OK);
-    classifier->Accumulate(binding_classifier,
-                           ExpressionClassifier::AllProductions);
+    classifier->ReportInvalidSimpleAssignmentTarget();
+    ExpressionClassifier expr_classifier;
+    ExpressionT right =
+        this->ParseAssignmentExpression(accept_IN, &expr_classifier, CHECK_OK);
+    classifier->Accumulate(expr_classifier,
+                           expr_classifier.is_destructuring_assignment()
+                               ? ExpressionClassifier::PatternProductions
+                               : ExpressionClassifier::AllProductions);
+
+
     result = factory()->NewBinaryOperation(Token::COMMA, result, right, pos);
   }
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseArrayLiteral(
     ExpressionClassifier* classifier, bool* ok) {
   // ArrayLiteral ::
   //   '[' Expression? (',' Expression?)* ']'
 
   int pos = peek_position();
   typename Traits::Type::ExpressionList values =
       this->NewExpressionList(4, zone_);
   Expect(Token::LBRACK, CHECK_OK);
   while (peek() != Token::RBRACK) {
     bool seen_spread = false;
     ExpressionT elem = this->EmptyExpression();
+    ExpressionClassifier element_classifier;
     if (peek() == Token::COMMA) {
       if (is_strong(language_mode())) {
         ReportMessageAt(scanner()->peek_location(),
                         MessageTemplate::kStrongEllision);
         *ok = false;
         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);
       elem = factory()->NewSpread(argument, start_pos);
       seen_spread = true;
     } else {
-      elem = this->ParseAssignmentExpression(true, classifier, CHECK_OK);
+      int start_pos = peek_position();
+      elem =
+          this->ParseAssignmentExpression(true, &element_classifier, CHECK_OK);
+      if (!element_classifier.IsValidSimpleAssignmentTarget() &&
+          !element_classifier.IsPatternAssignmentElement()) {
+        Scanner::Location location(start_pos, scanner()->location().end_pos);
+        classifier->RecordAssignmentPatternError(
+            location, MessageTemplate::kInvalidDestructuringAssignmentTarget);
+      }
+      classifier->Accumulate(element_classifier);
     }
     values->Add(elem, zone_);
     if (peek() != Token::RBRACK) {
       if (seen_spread) {
         BindingPatternUnexpectedToken(classifier);
       }
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RBRACK, CHECK_OK);
@@ skipping 73 matching lines @@
     ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
     bool is_static, bool* is_computed_name, bool* has_seen_constructor,
     ExpressionClassifier* classifier, bool* ok) {
   DCHECK(!in_class || is_static || has_seen_constructor != nullptr);
   ExpressionT value = this->EmptyExpression();
   IdentifierT name = this->EmptyIdentifier();
   bool is_get = false;
   bool is_set = false;
   bool name_is_static = false;
   bool is_generator = allow_harmony_object_literals_ && Check(Token::MUL);
-
+  // Classify destructuring assignment target for ObjectAssignmentPattern
+  ExpressionClassifier property_classifier;
   Token::Value name_token = peek();
   int next_beg_pos = scanner()->peek_location().beg_pos;
   int next_end_pos = scanner()->peek_location().end_pos;
+  int value_start = next_beg_pos;
+  int value_end = next_end_pos;
   ExpressionT name_expression = ParsePropertyName(
-      &name, &is_get, &is_set, &name_is_static, is_computed_name, classifier,
-      CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+      &name, &is_get, &is_set, &name_is_static, is_computed_name,
+      &property_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   if (fni_ != nullptr && !*is_computed_name) {
     this->PushLiteralName(fni_, name);
   }
 
   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);
+    property_classifier = ExpressionClassifier();
+    value_start = peek_position();
     value = this->ParseAssignmentExpression(
-        true, classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-
+        true, &property_classifier,
+        CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    value_end = scanner()->location().end_pos;
   } else if (is_generator ||
              (allow_harmony_object_literals_ && peek() == Token::LPAREN)) {
     // Concise Method
+    property_classifier.ReportInvalidSimpleAssignmentTarget();
     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 10 matching lines @@
         kind, RelocInfo::kNoPosition, FunctionLiteral::ANONYMOUS_EXPRESSION,
         FunctionLiteral::NORMAL_ARITY,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
 
   } else if (in_class && name_is_static && !is_static) {
     // static MethodDefinition
+    property_classifier.ReportInvalidSimpleAssignmentTarget();
     return ParsePropertyDefinition(checker, true, has_extends, true,
                                    is_computed_name, nullptr, classifier, ok);
   } else if (is_get || is_set) {
     // Accessor
+    property_classifier.ReportInvalidSimpleAssignmentTarget();
     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 11 matching lines @@
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     // Make sure the name expression is a string since we need a Name for
     // Runtime_DefineAccessorPropertyUnchecked and since we can determine this
     // statically we can skip the extra runtime check.
     if (!*is_computed_name) {
       name_expression =
           factory()->NewStringLiteral(name, name_expression->position());
     }
 
+    value_end = scanner()->location().end_pos;
+    Scanner::Location location(value_start, value_end);
+    classifier->RecordAssignmentPatternError(
+        location, MessageTemplate::kInvalidDestructuringAssignmentTarget);
+
     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);
 
     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));
+          true, 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();
   }
 
+  if (!property_classifier.IsValidSimpleAssignmentTarget() &&
+      !property_classifier.IsPatternAssignmentElement()) {
+    Scanner::Location location(value_start, value_end);
+    classifier->RecordAssignmentPatternError(
+        location, MessageTemplate::kInvalidDestructuringAssignmentTarget);
+  }
+  classifier->Accumulate(property_classifier);
+
   return factory()->NewObjectLiteralProperty(name_expression, value, is_static,
                                              *is_computed_name);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
     ExpressionClassifier* classifier, bool* ok) {
   // ObjectLiteral ::
   // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}'
@@ skipping 122 matching lines @@
     // the parser and preparser
     Traits::MaterializeUnspreadArgumentsLiterals(unspread_sequences_count);
   }
 
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
-ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
+ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN, bool pattern_lhs,
                                               ExpressionClassifier* classifier,
                                               bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
 
   Scanner::Location lhs_location = scanner()->peek_location();
 
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(classifier, ok);
   }
 
+  bool maybe_assignment_pattern =
+      allow_harmony_destructuring() &&
+      classifier->is_valid_assignment_pattern() &&
+      (peek() == Token::LBRACK || peek() == Token::LBRACE);
+
   if (fni_ != NULL) fni_->Enter();
   ParserBase<Traits>::Checkpoint checkpoint(this);
   ExpressionClassifier arrow_formals_classifier;
   if (peek() != Token::LPAREN) {
     // The expression we are going to read is not a parenthesized arrow function
     // formal parameter list.
     ArrowFormalParametersUnexpectedToken(&arrow_formals_classifier);
   }
+
   ExpressionT expression = this->ParseConditionalExpression(
       accept_IN, &arrow_formals_classifier, CHECK_OK);
+
+  if (!arrow_formals_classifier.is_valid_assignment_pattern()) {
+    if (maybe_assignment_pattern && peek() == Token::ASSIGN) {
+      // ObjectAssignmentPattern or ArrayAssignmentPattern contains an error
+      ReportClassifierError(
+          arrow_formals_classifier.assignment_pattern_error());
+      *ok = false;
+      return this->EmptyExpression();
+    }
+  }
+
   classifier->Accumulate(arrow_formals_classifier);
 
   if (allow_harmony_arrow_functions() && peek() == Token::ARROW) {
     checkpoint.Restore();
     BindingPatternUnexpectedToken(classifier);
+    classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_PRIMARY);
     ValidateArrowFormalParameters(&arrow_formals_classifier, expression,
                                   CHECK_OK);
     Scanner::Location loc(lhs_location.beg_pos, scanner()->location().end_pos);
     bool has_rest = false;
     Scope* scope =
         this->NewScope(scope_, ARROW_SCOPE, FunctionKind::kArrowFunction);
     scope->set_start_position(lhs_location.beg_pos);
     Scanner::Location duplicate_loc = Scanner::Location::invalid();
     this->ParseArrowFunctionFormalParameters(scope, expression, loc, &has_rest,
                                              &duplicate_loc, CHECK_OK);
     if (duplicate_loc.IsValid()) {
       arrow_formals_classifier.RecordDuplicateFormalParameterError(
           duplicate_loc);
     }
     expression = this->ParseArrowFunctionLiteral(
         scope, has_rest, arrow_formals_classifier, CHECK_OK);
     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::FormalParametersProduction);
 
+  bool valid_destructuring_assignment_target =
+      arrow_formals_classifier.IsValidSimpleAssignmentTarget();
+  if (valid_destructuring_assignment_target) {
+    classifier->AccumulateValidSimpleAssignmentTarget(arrow_formals_classifier);
+  } else if (!maybe_assignment_pattern ||
+             !arrow_formals_classifier.is_valid_assignment_pattern()) {
+    // Potentially a bad DestructuringAssignmentTarget
+    classifier->RecordAssignmentPatternError(
+        Scanner::Location(lhs_location.beg_pos, scanner()->location().end_pos),
+        MessageTemplate::kInvalidDestructuringAssignmentTarget);
+  }
+
+  if (maybe_assignment_pattern) {
+    classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_PATTERN);
+  }
+
+  if (pattern_lhs && peek() != Token::ASSIGN) {
+    // If LHS was an AssignmentPattern and there is no additional assignment,
+    // ensure that the RHS is a valid expression
+    ValidateExpression(classifier, CHECK_OK);
+    return expression;
+  }
+
   if (!Token::IsAssignmentOp(peek())) {
     if (fni_ != NULL) fni_->Leave();
     // Parsed conditional expression only (no assignment).
     return expression;
   }
 
   if (!allow_harmony_destructuring()) {
     BindingPatternUnexpectedToken(classifier);
   }
 
-  expression = this->CheckAndRewriteReferenceExpression(
-      expression, lhs_location, MessageTemplate::kInvalidLhsInAssignment,
-      CHECK_OK);
+  if (!maybe_assignment_pattern || peek() != Token::ASSIGN) {
+    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));
+  } else {
+    classifier->set_assigned();
   }
   int pos = position();
 
   ExpressionClassifier rhs_classifier;
-  ExpressionT right =
-      this->ParseAssignmentExpression(accept_IN, &rhs_classifier, CHECK_OK);
+  ExpressionT right = this->ParseAssignmentExpression(
+      accept_IN, maybe_assignment_pattern, &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();
   }
 
   this->CheckAssigningFunctionLiteralToProperty(expression, right);
 
   if (fni_ != NULL) {
     // Check if the right hand side is a call to avoid inferring a
     // name if we're dealing with "a = function(){...}();"-like
     // expression.
     if ((op == Token::INIT_VAR
          || 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);
+  return this->CheckDestructuringAssignment(result, classifier, CHECK_OK);
 }
 
 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 46 matching lines @@
   // ConditionalExpression ::
   //   LogicalOrExpression
   //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression
 
   int pos = peek_position();
   // We start using the binary expression parser for prec >= 4 only!
   ExpressionT expression =
       this->ParseBinaryExpression(4, accept_IN, classifier, CHECK_OK);
   if (peek() != Token::CONDITIONAL) return expression;
   BindingPatternUnexpectedToken(classifier);
+  classifier->ReportInvalidSimpleAssignmentTarget();
   Consume(Token::CONDITIONAL);
   // In parsing the first assignment expression in conditional
   // expressions we always accept the 'in' keyword; see ECMA-262,
   // section 11.12, page 58.
   ExpressionT left = ParseAssignmentExpression(true, classifier, CHECK_OK);
   Expect(Token::COLON, CHECK_OK);
   ExpressionT right =
       ParseAssignmentExpression(accept_IN, classifier, CHECK_OK);
   return factory()->NewConditional(expression, left, right, pos);
 }
 
 
 // Precedence >= 4
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseBinaryExpression(int prec, bool accept_IN,
                                           ExpressionClassifier* classifier,
                                           bool* ok) {
   DCHECK(prec >= 4);
   ExpressionT x = this->ParseUnaryExpression(classifier, CHECK_OK);
   for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {
     // prec1 >= 4
     while (Precedence(peek(), accept_IN) == prec1) {
       BindingPatternUnexpectedToken(classifier);
+      classifier->ReportInvalidSimpleAssignmentTarget();
       Token::Value op = Next();
       Scanner::Location op_location = scanner()->location();
       int pos = position();
       ExpressionT y =
           ParseBinaryExpression(prec1 + 1, accept_IN, classifier, CHECK_OK);
 
       if (this->ShortcutNumericLiteralBinaryExpression(&x, y, op, pos,
                                                        factory())) {
         continue;
       }
@@ skipping 42 matching lines @@
   //   '++' UnaryExpression
   //   '--' UnaryExpression
   //   '+' UnaryExpression
   //   '-' UnaryExpression
   //   '~' UnaryExpression
   //   '!' UnaryExpression
 
   Token::Value op = peek();
   if (Token::IsUnaryOp(op)) {
     BindingPatternUnexpectedToken(classifier);
-
+    classifier->ReportInvalidSimpleAssignmentTarget();
     op = Next();
     int pos = position();
     ExpressionT expression = ParseUnaryExpression(classifier, CHECK_OK);
 
     if (op == Token::DELETE && is_strict(language_mode())) {
       if (is_strong(language_mode())) {
         ReportMessage(MessageTemplate::kStrongDelete);
         *ok = false;
         return this->EmptyExpression();
       } else if (this->IsIdentifier(expression)) {
         // "delete identifier" is a syntax error in strict mode.
         ReportMessage(MessageTemplate::kStrictDelete);
         *ok = false;
         return this->EmptyExpression();
       }
     }
 
     // Allow Traits do rewrite the expression.
     return this->BuildUnaryExpression(expression, op, pos, factory());
   } else if (Token::IsCountOp(op)) {
     BindingPatternUnexpectedToken(classifier);
+    classifier->ReportInvalidSimpleAssignmentTarget();
     op = Next();
     Scanner::Location lhs_location = scanner()->peek_location();
     ExpressionT expression = this->ParseUnaryExpression(classifier, CHECK_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, MessageTemplate::kInvalidLhsInPrefixOp,
         CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
 
     return factory()->NewCountOperation(op,
                                         true /* prefix */,
@@ skipping 12 matching lines @@
                                            bool* ok) {
   // PostfixExpression ::
   //   LeftHandSideExpression ('++' | '--')?
 
   Scanner::Location lhs_location = scanner()->peek_location();
   ExpressionT expression =
       this->ParseLeftHandSideExpression(classifier, CHECK_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
     BindingPatternUnexpectedToken(classifier);
-
+    classifier->ReportInvalidSimpleAssignmentTarget();
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_location, MessageTemplate::kInvalidLhsInPostfixOp,
         CHECK_OK);
     expression = this->MarkExpressionAsAssigned(expression);
 
     Token::Value next = Next();
     expression =
         factory()->NewCountOperation(next,
                                      false /* postfix */,
                                      expression,
@@ skipping 10 matching lines @@
   // LeftHandSideExpression ::
   //   (NewExpression | MemberExpression) ...
 
   ExpressionT result =
       this->ParseMemberWithNewPrefixesExpression(classifier, CHECK_OK);
 
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         BindingPatternUnexpectedToken(classifier);
+        classifier->AppendAssignmentTarget(
+            ExpressionClassifier::TARGET_PROPERTY);
         Consume(Token::LBRACK);
         int pos = position();
-        ExpressionT index = ParseExpression(true, classifier, CHECK_OK);
+        ExpressionT index = ParseExpression(true, CHECK_OK);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
         BindingPatternUnexpectedToken(classifier);
-
+        classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_CALL);
         if (is_strong(language_mode()) && this->IsIdentifier(result) &&
             this->IsEval(this->AsIdentifier(result))) {
           ReportMessage(MessageTemplate::kStrongDirectEval);
           *ok = false;
           return this->EmptyExpression();
         }
         int pos;
         if (scanner()->current_token() == Token::IDENTIFIER) {
           // For call of an identifier we want to report position of
           // the identifier as position of the call in the stack trace.
@@ skipping 30 matching lines @@
           result = Traits::SpreadCall(result, args, pos);
         } else {
           result = factory()->NewCall(result, args, pos);
         }
         if (fni_ != NULL) fni_->RemoveLastFunction();
         break;
       }
 
       case Token::PERIOD: {
         BindingPatternUnexpectedToken(classifier);
+        classifier->AppendAssignmentTarget(
+            ExpressionClassifier::TARGET_PROPERTY);
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         result = factory()->NewProperty(
             result, factory()->NewStringLiteral(name, pos), pos);
         if (fni_ != NULL) this->PushLiteralName(fni_, name);
         break;
       }
 
       default:
@@ skipping 19 matching lines @@
   // Examples of new expression:
   // new foo.bar().baz means (new (foo.bar)()).baz
   // new foo()() means (new foo())()
   // new new foo()() means (new (new foo())())
   // new new foo means new (new foo)
   // new new foo() means new (new foo())
   // new new foo().bar().baz means (new (new foo()).bar()).baz
 
   if (peek() == Token::NEW) {
     BindingPatternUnexpectedToken(classifier);
+    classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_CALL);
     Consume(Token::NEW);
     int new_pos = position();
     ExpressionT result = this->EmptyExpression();
     if (peek() == Token::SUPER) {
       const bool is_new = true;
       result = ParseSuperExpression(is_new, classifier, CHECK_OK);
     } else {
       result = this->ParseMemberWithNewPrefixesExpression(classifier, CHECK_OK);
     }
     if (peek() == Token::LPAREN) {
@@ skipping 31 matching lines @@
   //     ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)*
 
   // The '[' Expression ']' and '.' Identifier parts are parsed by
   // ParseMemberExpressionContinuation, and the Arguments part is parsed by the
   // caller.
 
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
   if (peek() == Token::FUNCTION) {
     BindingPatternUnexpectedToken(classifier);
-
+    classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_PRIMARY);
     Consume(Token::FUNCTION);
     int function_token_position = position();
     bool is_generator = Check(Token::MUL);
     IdentifierT name = this->EmptyIdentifier();
     bool is_strict_reserved_name = false;
     Scanner::Location function_name_location = Scanner::Location::invalid();
     FunctionLiteral::FunctionType function_type =
         FunctionLiteral::ANONYMOUS_EXPRESSION;
     if (peek_any_identifier()) {
       name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
@@ skipping 168 matching lines @@
   while (scope->is_eval_scope() || scope->is_arrow_scope()) {
     scope = scope->outer_scope();
     DCHECK_NOT_NULL(scope);
     scope = scope->DeclarationScope();
   }
 
   FunctionKind kind = scope->function_kind();
   if (IsConciseMethod(kind) || IsAccessorFunction(kind) ||
       i::IsConstructor(kind)) {
     if (peek() == Token::PERIOD || peek() == Token::LBRACK) {
+      classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_PROPERTY);
       scope->RecordSuperPropertyUsage();
       return this->SuperPropertyReference(scope_, factory(), pos);
     }
     // new super() is never allowed.
     // super() is only allowed in derived constructor
     if (!is_new && peek() == Token::LPAREN && IsSubclassConstructor(kind)) {
+      classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_CALL);
       if (is_strong(language_mode())) {
         // Super calls in strong mode are parsed separately.
         ReportMessageAt(scanner()->location(),
                         MessageTemplate::kStrongConstructorSuper);
         *ok = false;
         return this->EmptyExpression();
       }
       // TODO(rossberg): This might not be the correct FunctionState for the
       // method here.
       function_state_->set_super_location(scanner()->location());
@@ skipping 10 matching lines @@
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseMemberExpressionContinuation(
     ExpressionT expression, ExpressionClassifier* classifier, bool* ok) {
   // Parses this part of MemberExpression:
   // ('[' Expression ']' | '.' Identifier | TemplateLiteral)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         BindingPatternUnexpectedToken(classifier);
-
+        classifier->AppendAssignmentTarget(
+            ExpressionClassifier::TARGET_PROPERTY);
         Consume(Token::LBRACK);
         int pos = position();
-        ExpressionT index = this->ParseExpression(true, classifier, CHECK_OK);
+        // Ignore pattern errors within expression
+        ExpressionClassifier prop_classifier;
+        ExpressionT index =
+            this->ParseExpression(true, &prop_classifier, CHECK_OK);
         expression = factory()->NewProperty(expression, index, pos);
         if (fni_ != NULL) {
           this->PushPropertyName(fni_, index);
         }
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
       case Token::PERIOD: {
         BindingPatternUnexpectedToken(classifier);
+        classifier->AppendAssignmentTarget(
+            ExpressionClassifier::TARGET_PROPERTY);
 
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         expression = factory()->NewProperty(
             expression, factory()->NewStringLiteral(name, pos), pos);
         if (fni_ != NULL) {
           this->PushLiteralName(fni_, name);
         }
         break;
       }
       case Token::TEMPLATE_SPAN:
       case Token::TEMPLATE_TAIL: {
         BindingPatternUnexpectedToken(classifier);
+        classifier->AppendAssignmentTarget(ExpressionClassifier::TARGET_CALL);
         int pos;
         if (scanner()->current_token() == Token::IDENTIFIER) {
           pos = position();
         } else {
           pos = peek_position();
           if (expression->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             // If the tag function looks like an IIFE, set_parenthesized() to
             // force eager compilation.
             expression->AsFunctionLiteral()->set_should_eager_compile();
           }
         }
+        // Ignore classifying tagged template
+        ExpressionClassifier call_classifier;
         expression =
-            ParseTemplateLiteral(expression, pos, classifier, CHECK_OK);
+            ParseTemplateLiteral(expression, pos, &call_classifier, CHECK_OK);
         break;
       }
       default:
         return expression;
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }
 
@@ skipping 371 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H