[async-iteration] add support for for-await-of loops in Async Functions

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 2949 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 };

[neis, 2017/01/20 14:38:15]

Can you instead use the IteratorType enum that you use in the parser?  Maybe
move it here.

+
+  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(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) {}
+  explicit GetIterator(Expression* iterable, Hint hint, int pos)
+      : Expression(pos, kGetIterator), hint_(hint), iterable_(iterable) {}
 
+  Hint hint_;
   Expression* iterable_;
   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 559 matching lines @@
                                             VariableProxy* this_function_var,
                                             int pos) {
     return new (zone_)
         SuperCallReference(this_var, new_target_var, this_function_var, pos);
   }
 
   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_) {
@@ skipping 57 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_