WIP [esnext] implement async iteration proposal

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-types.h"
 #include "src/ast/ast-value-factory.h"
@@ skipping 675 matching lines @@
 
   Statement* init_;
   Expression* cond_;
   Statement* next_;
 };
 
 
 class ForEachStatement : public IterationStatement {
  public:
   enum VisitMode {
-    ENUMERATE,   // for (each in subject) body;
-    ITERATE      // for (each of subject) body;
+    ENUMERATE,      // for (each in subject) body;
+    ITERATE,        // for (each of subject) body;
+    ASYNC_ITERATE,  // for await (each of subject) body;
   };
 
   using IterationStatement::Initialize;
 
   static const char* VisitModeString(VisitMode mode) {
-    return mode == ITERATE ? "for-of" : "for-in";
+    static const char* kModeStrings[] = {"for-in", "for-of", "for-await-of"};
+    DCHECK(mode >= ENUMERATE && mode <= ASYNC_ITERATE);
+    return kModeStrings[mode];
   }
 
  protected:
   ForEachStatement(ZoneList<const AstRawString*>* labels, int pos,
                    NodeType type)
       : IterationStatement(labels, pos, type) {}
 };
 
 
 class ForInStatement final : public ForEachStatement {
@@ skipping 115 matching lines @@
         result_done_(NULL),
         assign_each_(NULL) {}
 
   Variable* iterator_;
   Expression* assign_iterator_;
   Expression* next_result_;
   Expression* result_done_;
   Expression* assign_each_;
 };
 
-
 class ExpressionStatement final : public Statement {
  public:
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
   bool IsJump() const { return expression_->IsThrow(); }
 
  private:
   friend class AstNodeFactory;
 
   ExpressionStatement(Expression* expression, int pos)
@@ skipping 1625 matching lines @@
   class IsRewrittenField
       : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
 };
 
 // Our Yield is different from the JS yield in that it "returns" its argument as
 // is, without wrapping it in an iterator result object.  Such wrapping, if
 // desired, must be done beforehand (see the parser).
 class Yield final : public Expression {
  public:
   enum OnException { kOnExceptionThrow, kOnExceptionRethrow };
+  enum YieldType { kNormal, kAwait };
 
   Expression* generator_object() const { return generator_object_; }
   Expression* expression() const { return expression_; }
   OnException on_exception() const {
     return OnExceptionField::decode(bit_field_);
   }
   bool rethrow_on_exception() const {
     return on_exception() == kOnExceptionRethrow;
   }
   int yield_id() const { return yield_id_; }
+  YieldType yield_type() const { return YieldTypeField::decode(bit_field_); }
 
   void set_generator_object(Expression* e) { generator_object_ = e; }
   void set_expression(Expression* e) { expression_ = e; }
   void set_yield_id(int yield_id) { yield_id_ = yield_id; }
+  void set_yield_type(YieldType type) {
+    bit_field_ = YieldTypeField::update(bit_field_, type);
+  }
 
  private:
   friend class AstNodeFactory;
 
   Yield(Expression* generator_object, Expression* expression, int pos,
-        OnException on_exception)
+        OnException on_exception, YieldType yield_type = kNormal)
       : Expression(pos, kYield),
         yield_id_(-1),
         generator_object_(generator_object),
         expression_(expression) {
-    bit_field_ |= OnExceptionField::encode(on_exception);
+    bit_field_ |= OnExceptionField::encode(on_exception) |
+                  YieldTypeField::encode(yield_type);
   }
 
   int yield_id_;
   Expression* generator_object_;
   Expression* expression_;
 
   class OnExceptionField
       : public BitField<OnException, Expression::kNextBitFieldIndex, 1> {};
+  class YieldTypeField
+      : public BitField<YieldType, OnExceptionField::kNext, 1> {};
 };
 
 
 class Throw final : public Expression {
  public:
   Expression* exception() const { return exception_; }
   void set_exception(Expression* e) { exception_ = e; }
 
  private:
   friend class AstNodeFactory;
@@ skipping 379 matching lines @@
 
   explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {}
 };
 
 // Represents the spec operation `GetIterator()`
 // (defined at https://tc39.github.io/ecma262/#sec-getiterator). Ignition
 // desugars this into a LoadIC / JSLoadNamed, CallIC, and a type-check to
 // validate return value of the Symbol.iterator() call.
 class GetIterator final : public Expression {
  public:
+  enum Hint { kNormal, kAsync };
+
+  Hint hint() const { return hint_; }
+
   Expression* iterable() const { return iterable_; }
   void set_iterable(Expression* iterable) { iterable_ = iterable; }
 
   static int num_ids() { return parent_num_ids(); }
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) {
     iterator_property_feedback_slot_ =
         spec->AddSlot(FeedbackVectorSlotKind::LOAD_IC);
     iterator_call_feedback_slot_ =
         spec->AddSlot(FeedbackVectorSlotKind::CALL_IC);
+    if (hint() == kAsync) {
+      // Can we just re-use the other slots?
+      async_iterator_property_feedback_slot_ =
+          spec->AddSlot(FeedbackVectorSlotKind::LOAD_IC);
+      async_iterator_call_feedback_slot_ =
+          spec->AddSlot(FeedbackVectorSlotKind::CALL_IC);
+    }
   }
 
   FeedbackVectorSlot IteratorPropertyFeedbackSlot() const {
     return iterator_property_feedback_slot_;
   }
 
   FeedbackVectorSlot IteratorCallFeedbackSlot() const {
     return iterator_call_feedback_slot_;
   }
 
+  FeedbackVectorSlot AsyncIteratorPropertyFeedbackSlot() const {
+    return async_iterator_property_feedback_slot_;
+  }
+
+  FeedbackVectorSlot AsyncIteratorCallFeedbackSlot() const {
+    return async_iterator_call_feedback_slot_;
+  }
+
  private:
   friend class AstNodeFactory;
 
   explicit GetIterator(Expression* iterable, int pos)
-      : Expression(pos, kGetIterator), iterable_(iterable) {}
+      : Expression(pos, kGetIterator), iterable_(iterable), hint_(kNormal) {}
+
+  explicit GetIterator(Expression* iterable, Hint hint, int pos)
+      : Expression(pos, kGetIterator), iterable_(iterable), hint_(hint) {}
 
   Expression* iterable_;
+  Hint hint_;
   FeedbackVectorSlot iterator_property_feedback_slot_;
   FeedbackVectorSlot iterator_call_feedback_slot_;
+  FeedbackVectorSlot async_iterator_property_feedback_slot_;
+  FeedbackVectorSlot async_iterator_call_feedback_slot_;
 };
 
 // ----------------------------------------------------------------------------
 // Basic visitor
 // Sub-class should parametrize AstVisitor with itself, e.g.:
 //   class SpecificVisitor : public AstVisitor<SpecificVisitor> { ... }
 
 template <class Subclass>
 class AstVisitor BASE_EMBEDDED {
  public:
@@ skipping 187 matching lines @@
   STATEMENT_WITH_LABELS(SwitchStatement)
 #undef STATEMENT_WITH_LABELS
 
   ForEachStatement* NewForEachStatement(ForEachStatement::VisitMode visit_mode,
                                         ZoneList<const AstRawString*>* labels,
                                         int pos) {
     switch (visit_mode) {
       case ForEachStatement::ENUMERATE: {
         return new (zone_) ForInStatement(labels, pos);
       }
-      case ForEachStatement::ITERATE: {
+      case ForEachStatement::ITERATE:
+      case ForEachStatement::ASYNC_ITERATE: {
         return new (zone_) ForOfStatement(labels, pos);
       }
     }
     UNREACHABLE();
     return NULL;
   }
 
   ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
     return new (zone_) ExpressionStatement(expression, pos);
   }
@@ skipping 259 matching lines @@
 
     Assignment* assign = new (zone_) Assignment(op, target, value, pos);
     if (assign->is_compound()) {
       assign->binary_operation_ =
           NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
     }
     return assign;
   }
 
   Yield* NewYield(Expression* generator_object, Expression* expression, int pos,
-                  Yield::OnException on_exception) {
+                  Yield::OnException on_exception,
+                  Yield::YieldType type = Yield::kNormal) {
     if (!expression) expression = NewUndefinedLiteral(pos);
-    return new (zone_) Yield(generator_object, expression, pos, on_exception);
+    return new (zone_)
+        Yield(generator_object, expression, pos, on_exception, type);
   }
 
   Throw* NewThrow(Expression* exception, int pos) {
     return new (zone_) Throw(exception, pos);
   }
 
   FunctionLiteral* NewFunctionLiteral(
       const AstRawString* name, DeclarationScope* scope,
       ZoneList<Statement*>* body, int materialized_literal_count,
       int expected_property_count, int parameter_count, int function_length,
@@ skipping 72 matching lines @@
   }
 
   EmptyParentheses* NewEmptyParentheses(int pos) {
     return new (zone_) EmptyParentheses(pos);
   }
 
   GetIterator* NewGetIterator(Expression* iterable, int pos) {
     return new (zone_) GetIterator(iterable, pos);
   }
 
+  GetIterator* NewGetIterator(Expression* iterable, GetIterator::Hint hint,
+                              int pos) {
+    return new (zone_) GetIterator(iterable, hint, pos);
+  }
+
   Zone* zone() const { return zone_; }
   void set_zone(Zone* zone) { zone_ = zone; }
 
   // Handles use of temporary zones when parsing inner function bodies.
   class BodyScope {
    public:
     BodyScope(AstNodeFactory* factory, Zone* temp_zone, bool use_temp_zone)
         : factory_(factory), prev_zone_(factory->zone_) {
       if (use_temp_zone) {
         factory->zone_ = temp_zone;
@@ skipping 55 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_