[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_); }
+
+  bool IsRewritableAs(RewriteHint hint) const {
+    return (RewriteHintsField::decode(bit_field_) & hint) != 0 &&
+           !IsRewrittenAs(hint);
+  }
+
+  bool IsRewrittenAs(RewriteHint reason) const {
+    return (RewriteReasonField::decode(bit_field_) & reason) != 0;
+  }
+
+  void RewriteAs(Expression* new_expression, RewriteHint reason) {
+    DCHECK(!IsRewrittenAs(reason));
+    DCHECK((RewriteHintsField::decode(bit_field_) & reason) != 0);
+    expr_ = new_expression;
+    bit_field_ = RewriteReasonField::update(bit_field_, reason);
+  }
+
+
+ protected:
+  RewritableExpression(Zone* zone, Expression* expression, int hints)
+      : Expression(zone, expression->position()),
+        expr_(expression),
+        bit_field_(RewriteHintsField::encode(hints)) {}
+
+ private:
+  Expression* expr_;

[adamk, 2015/12/01 22:42:56]

Nit: just call this "expression_"

+  uint32_t bit_field_;

[adamk, 2015/12/01 22:42:56]

If you move this before expr_ and make it a uint8_t, it'll get packed in with
the 16 bit field in Expression (that seems to be the suggested pattern elsewhere
in ast.h)

Alternatively, this node is currently way more generic than necessary. You could
make it more specific to the current use case and simplify much of the logic
above, using a bool to track state instead of the bitfield.

I think I prefer the latter; otherwise there are lots of places in the code
where we check for a RewriteHint that's always true. Probably rename to
RewritableAssignmentExpression in that case.

+  class RewriteHintsField : public BitField<uint16_t, 0, 16> {};
+  class RewriteReasonField
+      : public BitField<uint16_t, RewriteHintsField::kNext, 16> {};
+};
+
+
 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 1912 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_