[debugger] omit exception events for rethrown exceptions in async.

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-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 2493 matching lines @@
   Expression* expr_;
 };
 
 // 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:
   DECLARE_NODE_TYPE(Yield)
 
+  enum OnException { kOnExceptionThrow, kOnExceptionRethrow };
+
   Expression* generator_object() const { return generator_object_; }
   Expression* expression() const { return expression_; }
+  bool rethrow_on_exception() const {
+    return on_exception_ == kOnExceptionRethrow;
+  }
   int yield_id() const { return yield_id_; }
 
   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; }
 
  protected:
   Yield(Zone* zone, Expression* generator_object, Expression* expression,
-        int pos)
+        int pos, OnException on_exception)
       : Expression(zone, pos),
         generator_object_(generator_object),
         expression_(expression),
+        on_exception_(on_exception),
         yield_id_(-1) {}
 
  private:
   Expression* generator_object_;
   Expression* expression_;
+  OnException on_exception_;
   int yield_id_;
 };
 
 
 class Throw final : public Expression {
  public:
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
   void set_exception(Expression* e) { exception_ = e; }
@@ skipping 849 matching lines @@
     Assignment* assign =
         new (local_zone_) Assignment(local_zone_, op, target, value, pos);
     if (assign->is_compound()) {
       DCHECK(Token::IsAssignmentOp(op));
       assign->binary_operation_ =
           NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
     }
     return assign;
   }
 
-  Yield* NewYield(Expression *generator_object,
-                  Expression* expression,
-                  int pos) {
+  Yield* NewYield(Expression* generator_object, Expression* expression, int pos,
+                  Yield::OnException on_exception) {
     if (!expression) expression = NewUndefinedLiteral(pos);
     return new (local_zone_)
-        Yield(local_zone_, generator_object, expression, pos);
+        Yield(local_zone_, generator_object, expression, pos, on_exception);
   }
 
   Throw* NewThrow(Expression* exception, int pos) {
     return new (local_zone_) Throw(local_zone_, exception, pos);
   }
 
   FunctionLiteral* NewFunctionLiteral(
       const AstRawString* name, Scope* scope, ZoneList<Statement*>* body,
       int materialized_literal_count, int expected_property_count,
       int parameter_count,
@@ skipping 137 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_