[async-functions] support await expressions in finally statements

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/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 84 matching lines @@
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
   V(SuperPropertyReference)     \
   V(SuperCallReference)         \
   V(CaseClause)                 \
   V(EmptyParentheses)           \
+  V(InternalVariable)           \
   V(GetIterator)                \
   V(DoExpression)               \
   V(RewritableExpression)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
@@ skipping 2394 matching lines @@
       : 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 };
 
-  Expression* generator_object() const { return generator_object_; }
+  enum YieldType { kNormal, kAwait };
+
   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_); }

[caitp, 2017/01/30 04:20:29]

Await gets desugared in the bytecode generator now, rather than in the parser.
So this information helps generate the correct bytecode

 
-  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; }
 
  private:
   friend class AstNodeFactory;
 
-  Yield(Expression* generator_object, Expression* expression, int pos,
-        OnException on_exception)
-      : Expression(pos, kYield),
-        yield_id_(-1),
-        generator_object_(generator_object),
-        expression_(expression) {
-    bit_field_ |= OnExceptionField::encode(on_exception);
+  Yield(Expression* expression, int pos, OnException on_exception,
+        YieldType yield_type)
+      : Expression(pos, kYield), yield_id_(-1), expression_(expression) {
+    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 17 matching lines @@
   enum IdType { kIdTypeInvalid = -1, kIdTypeTopLevel = 0 };
 
   enum ParameterFlag { kNoDuplicateParameters, kHasDuplicateParameters };
 
   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstString* raw_name() const { return raw_name_; }
   void set_raw_name(const AstString* name) { raw_name_ = name; }
   DeclarationScope* scope() const { return scope_; }
+
+  // AST desugaring of initialization of non-simple parameters. If non-null,
+  // forces Ignition/TF pipeline.
+  Block* parameter_init_block() const { return parameter_init_block_; }
+  void set_parameter_init_block(Block* block) { parameter_init_block_ = block; }

[caitp, 2017/01/30 04:20:29]

Separating this from the function's "body" allows BytecodeGenerator to have more
control over how the code is generated, including wrapping parameter
initialization in a try/catch/finally block. Doing all of this in bytecode fixes
a TODO of Dan's

+
   ZoneList<Statement*>* body() const { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const;
   int end_position() const;
   int SourceSize() const { return end_position() - start_position(); }
   bool is_declaration() const { return function_type() == kDeclaration; }
   bool is_named_expression() const {
     return function_type() == kNamedExpression;
   }
@@ skipping 129 matching lines @@
       : Expression(position, kFunctionLiteral),
         materialized_literal_count_(materialized_literal_count),
         expected_property_count_(expected_property_count),
         parameter_count_(parameter_count),
         function_length_(function_length),
         function_token_position_(kNoSourcePosition),
         yield_count_(0),
         has_braces_(has_braces),
         raw_name_(name),
         scope_(scope),
+        parameter_init_block_(nullptr),
         body_(body),
         raw_inferred_name_(ast_value_factory->empty_string()),
         ast_properties_(zone),
         function_literal_id_(function_literal_id) {
     bit_field_ |= FunctionTypeBits::encode(function_type) |
                   Pretenure::encode(false) |
                   HasDuplicateParameters::encode(has_duplicate_parameters ==
                                                  kHasDuplicateParameters) |
                   ShouldNotBeUsedOnceHintField::encode(false) |
                   DontOptimizeReasonField::encode(kNoReason);
@@ skipping 13 matching lines @@
   int materialized_literal_count_;
   int expected_property_count_;
   int parameter_count_;
   int function_length_;
   int function_token_position_;
   int yield_count_;
   bool has_braces_;
 
   const AstString* raw_name_;
   DeclarationScope* scope_;
+  Block* parameter_init_block_;
   ZoneList<Statement*>* body_;
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
   int function_literal_id_;
   FeedbackVectorSlot literal_feedback_slot_;
 };
 
 // Property is used for passing information
 // about a class literal's properties from the parser to the code generator.
@@ skipping 171 matching lines @@
 
 // This class is produced when parsing the () in arrow functions without any
 // arguments and is not actually a valid expression.
 class EmptyParentheses final : public Expression {
  private:
   friend class AstNodeFactory;
 
   explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {}
 };
 
+class InternalVariable final : public Expression {

[caitp, 2017/01/30 04:20:29]

Originally this was used for a lot of different things, but since moving much of
the parser desugaring into BytecodeGenerator, it's now only used for
function.sent.

This class can be eliminated if function.sent just gets its own AST node
instead.

+ public:
+  enum Type { kGeneratorObject };
+
+  Type type() const { return type_; }
+
+  const char* name() const;
+
+ private:
+  friend class AstNodeFactory;
+
+  explicit InternalVariable(Type type)
+      : Expression(kNoSourcePosition, kInternalVariable), type_(type) {}
+
+  Type type_;
+};
+
 // 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:
   Expression* iterable() const { return iterable_; }
   void set_iterable(Expression* iterable) { iterable_ = iterable; }
 
   static int num_ids() { return parent_num_ids(); }
@@ skipping 503 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* NewYield(Expression* expression, int pos,

[caitp, 2017/01/30 04:20:29]

Yield no longer takes a generator object as a parameter, since it's always the
"own" generator object that yields, and that can be accessed via the
BytecodeGenerator.

+                  Yield::OnException on_exception, Yield::YieldType type) {
     if (!expression) expression = NewUndefinedLiteral(pos);
-    return new (zone_) Yield(generator_object, expression, pos, on_exception);
+    return new (zone_) Yield(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 68 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);
   }
 
+  InternalVariable* NewInternalVariable(InternalVariable::Type type) {
+    return new (zone_) InternalVariable(type);
+  }
+
   GetIterator* NewGetIterator(Expression* iterable, int pos) {
     return new (zone_) GetIterator(iterable, 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:
@@ skipping 59 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_