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

src/parsing/parser.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_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/base/compiler-specific.h"
@@ skipping 438 matching lines @@
     Block* block_;
     const DeclarationDescriptor* descriptor_;
     ZoneList<const AstRawString*>* names_;
     Expression* current_value_;
     int recursion_level_;
     bool* ok_;
 
     DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW()
   };
 
-  // !%_IsJSReceiver(result = iterator.next()) &&
-  //     %ThrowIteratorResultNotAnObject(result)
+  // [if (IteratorType == kAsync)]
+  //     !%_IsJSReceiver(result = Await(iterator.next()) &&
+  //         %ThrowIteratorResultNotAnObject(result)
+  // [else]
+  //     !%_IsJSReceiver(result = iterator.next()) &&
+  //         %ThrowIteratorResultNotAnObject(result)
+  // [endif]
   Expression* BuildIteratorNextResult(Expression* iterator, Variable* result,
-                                      int pos);
+                                      IteratorType type, int pos);
 
   // Initialize the components of a for-in / for-of statement.
   Statement* InitializeForEachStatement(ForEachStatement* stmt,
                                         Expression* each, Expression* subject,
                                         Statement* body, int each_keyword_pos);
-  Statement* InitializeForOfStatement(ForOfStatement* stmt, Expression* each,
+  Statement* InitializeForOfStatement(ForEachStatement* stmt, Expression* each,

[nickie, 2017/02/14 13:35:24]

Maybe it's trivial, but it strikes me as odd that a method called
"InitializeForOfStatement" now operates on a "ForEachStatement".  (How does this
relate to "InitializeForEachStatement"?)

Looking at the changes in the function's implementation, where a DCHECK is used
for making sure that the ForEachStatement is really a ForOfStatement, I'm
wondering what was the purpose of this change.

[caitp, 2017/02/14 14:16:37]

The purpose was to allow InitializeForOfStatement to be invoked directly by the
parser, rather than through InitializeForEachStatement().

There are some other ways to do this, but they'd involve more changes to ast.h,
which would necessarily result in adding some unreachable switch cases to a few
methods.

[adamk, 2017/02/14 18:47:53]

I can think of a variety of solutions for this that don't involve updating any
switch statements. For example, you could add a NewForOfStatement() to
AstNodeFactory (and PreParserFactory). Or you could add an AsForOfStatement()
method to PreParserStatement. The former already has another ideal caller in
parser.cc, while the latter is quite minimal.

[caitp, 2017/02/14 21:40:58]

Done via NewForOf...

                                       Expression* iterable, Statement* body,
-                                      bool finalize,
+                                      bool finalize, IteratorType type,
                                       int next_result_pos = kNoSourcePosition);
+
   Block* RewriteForVarInLegacy(const ForInfo& for_info);
   void DesugarBindingInForEachStatement(ForInfo* for_info, Block** body_block,
                                         Expression** each_variable, bool* ok);
   Block* CreateForEachStatementTDZ(Block* init_block, const ForInfo& for_info,
                                    bool* ok);
 
   Statement* DesugarLexicalBindingsInForStatement(
       ForStatement* loop, Statement* init, Expression* cond, Statement* next,
       Statement* body, Scope* inner_scope, const ForInfo& for_info, bool* ok);
 
@@ skipping 151 matching lines @@
   Expression* BuildRejectPromise(Expression* value, int pos);
   Variable* PromiseVariable();
 
   // Generic AST generator for throwing errors from compiled code.
   Expression* NewThrowError(Runtime::FunctionId function_id,
                             MessageTemplate::Template message,
                             const AstRawString* arg, int pos);
 
   void FinalizeIteratorUse(Scope* use_scope, Variable* completion,
                            Expression* condition, Variable* iter,
-                           Block* iterator_use, Block* result);
+                           Block* iterator_use, Block* result,
+                           IteratorType type);
 
   Statement* FinalizeForOfStatement(ForOfStatement* loop, Variable* completion,
-                                    int pos);
+                                    IteratorType type, int pos);
   void BuildIteratorClose(ZoneList<Statement*>* statements, Variable* iterator,
                           Variable* input, Variable* output);
   void BuildIteratorCloseForCompletion(Scope* scope,
                                        ZoneList<Statement*>* statements,
                                        Variable* iterator,
-                                       Expression* completion);
+                                       Expression* completion,
+                                       IteratorType type);
   Statement* CheckCallable(Variable* var, Expression* error, int pos);
 
   V8_INLINE Expression* RewriteAwaitExpression(Expression* value, int pos);
   V8_INLINE void PrepareAsyncFunctionBody(ZoneList<Statement*>* body,
                                           FunctionKind kind, int pos);
   V8_INLINE void RewriteAsyncFunctionBody(ZoneList<Statement*>* body,
                                           Block* block,
                                           Expression* return_value, bool* ok);
 
   Expression* RewriteYieldStar(Expression* generator, Expression* expression,
@@ skipping 515 matching lines @@
 
  private:
   ParserTarget** variable_;
   ParserTarget* previous_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_