[es6] implement destructuring assignment

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 73 matching lines @@
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
   V(SuperPropertyReference)     \
   V(SuperCallReference)         \
   V(CaseClause)                 \
   V(EmptyParentheses)           \
-  V(DoExpression)
+  V(DoExpression)               \
+  V(RewritableExpression)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
 class Declaration;
@@ skipping 290 matching lines @@
 
   int base_id_;
   Bounds bounds_;
   class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
   uint16_t bit_field_;
   // Ends with 16-bit field; deriving classes in turn begin with
   // 16-bit fields for optimum packing efficiency.
 };
 
 
+class RewritableExpression : public Expression {
+ public:
+  DECLARE_NODE_TYPE(RewritableExpression)
+
+  enum RewriteHint {
+    // Reasons for a rewrite to occur.
+    kDestructuringAssignment = 1,
+  };
+
+  Expression* expression() { return expr_; }
+  int hints() const { return RewriteHintsField::decode(bit_field_); }

[adamk, 2015/12/02 01:13:13]

This returns an int, but will only ever be kDestructuringAssignment

+
+  bool IsRewritableAs(RewriteHint hint) const {

[adamk, 2015/12/02 01:13:13]

There is only a single argument that could be passed here

+    return (RewriteHintsField::decode(bit_field_) & hint) != 0 &&
+           !IsRewrittenAs(hint);
+  }
+
+  bool IsRewrittenAs(RewriteHint reason) const {

[adamk, 2015/12/02 01:13:13]

Ditto

+    return (RewriteReasonField::decode(bit_field_) & reason) != 0;
+  }
+
+  void RewriteAs(Expression* new_expression, RewriteHint reason) {

[adamk, 2015/12/02 01:13:13]

And again, the second argument here is can only ever be one thing

+    DCHECK(!IsRewrittenAs(reason));
+    DCHECK((RewriteHintsField::decode(bit_field_) & reason) != 0);
+    expr_ = new_expression;
+    bit_field_ = RewriteReasonField::update(bit_field_, reason);
+  }
+
+  static int num_ids() { return parent_num_ids(); }
+
+ protected:
+  RewritableExpression(Zone* zone, Expression* expression, int hints)
+      : Expression(zone, expression->position()),
+        bit_field_(RewriteHintsField::encode(hints)),
+        expr_(expression) {}
+
+ private:
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+  uint8_t bit_field_;
+  Expression* expr_;
+  class RewriteHintsField : public BitField<uint16_t, 0, 4> {};

[adamk, 2015/12/02 01:13:13]

This bit field wouldn't be necessary, you could have one bool thats
'is_rewritten_'

+  class RewriteReasonField
+      : public BitField<uint16_t, RewriteHintsField::kNext, 4> {};
+};
+
+
 class BreakableStatement : public Statement {
  public:
   enum BreakableType {
     TARGET_FOR_ANONYMOUS,
     TARGET_FOR_NAMED_ONLY
   };
 
   // The labels associated with this statement. May be NULL;
   // if it is != NULL, guaranteed to contain at least one entry.
   ZoneList<const AstRawString*>* labels() const { return labels_; }
@@ skipping 1911 matching lines @@
  public:
   DECLARE_NODE_TYPE(Assignment)
 
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return TokenField::decode(bit_field_); }
   Expression* target() const { return target_; }
   Expression* value() const { return value_; }
+
   BinaryOperation* binary_operation() const { return binary_operation_; }
 
   // This check relies on the definition order of token in token.h.
   bool is_compound() const { return op() > Token::ASSIGN; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
 
   // Type feedback information.
   TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
@@ skipping 27 matching lines @@
 
  protected:
   Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
              int pos);
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsUninitializedField : public BitField16<bool, 0, 1> {};
-  class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
-  class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
-  class TokenField : public BitField16<Token::Value, 5, 8> {};
+  class KeyTypeField
+      : public BitField16<IcCheckType, IsUninitializedField::kNext, 1> {};
+  class StoreModeField
+      : public BitField16<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
+  class TokenField : public BitField16<Token::Value, StoreModeField::kNext, 8> {
+  };
 
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   SmallMapList receiver_types_;
   FeedbackVectorSlot slot_;
 };
@@ skipping 792 matching lines @@
   virtual void VisitStatements(ZoneList<Statement*>* statements);
   virtual void VisitExpressions(ZoneList<Expression*>* expressions);
 
   // Individual AST nodes.
 #define DEF_VISIT(type)                         \
   virtual void Visit##type(type* node) = 0;
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
-
 #define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
  public:                                                    \
   void Visit(AstNode* node) final {                         \
     if (!CheckStackOverflow()) node->Accept(this);          \
   }                                                         \
                                                             \
   void SetStackOverflow() { stack_overflow_ = true; }       \
   void ClearStackOverflow() { stack_overflow_ = false; }    \
   bool HasStackOverflow() const { return stack_overflow_; } \
                                                             \
@@ skipping 332 matching lines @@
   }
 
   Conditional* NewConditional(Expression* condition,
                               Expression* then_expression,
                               Expression* else_expression,
                               int position) {
     return new (local_zone_) Conditional(
         local_zone_, condition, then_expression, else_expression, position);
   }
 
+  RewritableExpression* NewRewritableExpression(Expression* expression,
+                                                int hints) {
+    DCHECK_NOT_NULL(expression);
+    DCHECK(hints);
+    return new (local_zone_)
+        RewritableExpression(local_zone_, expression, hints);
+  }
+
   Assignment* NewAssignment(Token::Value op,
                             Expression* target,
                             Expression* value,
                             int pos) {
     DCHECK(Token::IsAssignmentOp(op));
     Assignment* assign =
         new (local_zone_) Assignment(local_zone_, op, target, value, pos);
     if (assign->is_compound()) {
       DCHECK(Token::IsAssignmentOp(op));
       assign->binary_operation_ =
@@ skipping 105 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_