[es6] parse destructuring assignment

src/expression-classifier.h

 // Copyright 2015 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_EXPRESSION_CLASSIFIER_H
 #define V8_EXPRESSION_CLASSIFIER_H
 
 #include "src/v8.h"
 
 #include "src/messages.h"
@@ skipping 30 matching lines @@
         (BindingPatternProduction | AssignmentPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction |
                                    StrongModeFormalParametersProduction),
     StandardProductions = ExpressionProduction | PatternProductions,
     AllProductions = (StandardProductions | FormalParametersProductions |
                       ArrowFormalParametersProduction)
   };
 
   ExpressionClassifier()
-      : invalid_productions_(0), duplicate_finder_(nullptr) {}
+      : lhs_type_(TARGET_NONE),
+        assigned_(false),
+        invalid_productions_(0),
+        duplicate_finder_(nullptr) {}
 
   explicit ExpressionClassifier(DuplicateFinder* duplicate_finder)
-      : invalid_productions_(0), duplicate_finder_(duplicate_finder) {}
+      : lhs_type_(TARGET_NONE),
+        assigned_(false),
+        invalid_productions_(0),
+        duplicate_finder_(duplicate_finder) {}
+
+  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,
+
+    // 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();
+  }
+
+  inline bool IsValidPattern() const { return lhs_type_ == TARGET_PATTERN; }
+
+  inline bool IsAssigned() const { return assigned_; }
+
+  void set_assigned() { assigned_ = true; }
+
+  bool is_destructuring_assignment() const {
+    return IsValidPattern() && IsAssigned();
+  }
+
 
   bool is_valid(unsigned productions) const {
     return (invalid_productions_ & productions) == 0;
   }
 
   DuplicateFinder* duplicate_finder() const { return duplicate_finder_; }
 
   bool is_valid_expression() const { return is_valid(ExpressionProduction); }
 
   bool is_valid_binding_pattern() const {
@@ skipping 113 matching lines @@
   void RecordStrongModeFormalParameterError(const Scanner::Location& loc,
                                             MessageTemplate::Template message,
                                             const char* arg = nullptr) {
     if (!is_valid_strong_mode_formal_parameters()) return;
     invalid_productions_ |= StrongModeFormalParametersProduction;
     strong_mode_formal_parameter_error_.location = loc;
     strong_mode_formal_parameter_error_.message = message;
     strong_mode_formal_parameter_error_.arg = arg;
   }
 
+  void AccumulateValidSimpleAssignmentTarget(
+      const ExpressionClassifier& inner) {
+    if (lhs_type_ != UNACCEPTABLE_TARGET) {
+      lhs_type_ = inner.lhs_type_;
+    }
+  }
+
+
   void Accumulate(const ExpressionClassifier& inner,
                   unsigned productions = StandardProductions) {
     // Propagate errors from inner, but don't overwrite already recorded
     // errors.
     unsigned non_arrow_inner_invalid_productions =
         inner.invalid_productions_ & ~ArrowFormalParametersProduction;
     if (non_arrow_inner_invalid_productions == 0) return;
     unsigned non_arrow_productions =
         productions & ~ArrowFormalParametersProduction;
     unsigned errors =
@@ skipping 34 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_;
   unsigned invalid_productions_;
   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_;
   DuplicateFinder* duplicate_finder_;
 };
 }
 }  // v8::internal
 
 #endif  // V8_EXPRESSION_CLASSIFIER_H