[debug] use catch prediction flag for promise rejections.

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 1074 matching lines @@
   // Prediction of whether exceptions thrown into the handler for this try block
   // will be caught.
   //
   // This is set in ast-numbering and later compiled into the code's handler
   // table.  The runtime uses this information to implement a feature that
   // notifies the debugger when an uncaught exception is thrown, _before_ the
   // exception propagates to the top.
   //
   // Since it's generally undecidable whether an exception will be caught, our
   // prediction is only an approximation.
-  bool catch_predicted() const { return catch_predicted_; }
-  void set_catch_predicted(bool b) { catch_predicted_ = b; }
+  HandlerTable::CatchPrediction catch_prediction() const {
+    return catch_prediction_;
+  }
+  void set_catch_prediction(HandlerTable::CatchPrediction prediction) {
+    catch_prediction_ = prediction;
+  }
 
  protected:
   TryStatement(Zone* zone, Block* try_block, int pos, NodeType type)
       : Statement(zone, pos, type),
-        catch_predicted_(false),
+        catch_prediction_(HandlerTable::UNCAUGHT),
         try_block_(try_block) {}
 
+  HandlerTable::CatchPrediction catch_prediction_;
+
  private:
-  bool catch_predicted_;
   Block* try_block_;
 };
 
 
 class TryCatchStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
   void set_catch_block(Block* b) { catch_block_ = b; }
 
   // The clear_pending_message flag indicates whether or not to clear the
   // isolate's pending exception message before executing the catch_block.  In
   // the normal use case, this flag is always on because the message object
   // is not needed anymore when entering the catch block and should not be kept
   // alive.
   // The use case where the flag is off is when the catch block is guaranteed to
   // rethrow the caught exception (using %ReThrow), which reuses the pending
   // message instead of generating a new one.
   // (When the catch block doesn't rethrow but is guaranteed to perform an
   // ordinary throw, not clearing the old message is safe but not very useful.)
-  bool clear_pending_message() { return clear_pending_message_; }
+  bool clear_pending_message() const {
+    return catch_prediction_ != HandlerTable::UNCAUGHT;
+  }
 
  protected:
   TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
                     Variable* variable, Block* catch_block,
-                    bool clear_pending_message, int pos)
+                    HandlerTable::CatchPrediction catch_prediction, int pos)
       : TryStatement(zone, try_block, pos, kTryCatchStatement),
-        clear_pending_message_(clear_pending_message),
         scope_(scope),
         variable_(variable),
-        catch_block_(catch_block) {}
+        catch_block_(catch_block) {
+    catch_prediction_ = catch_prediction;
+  }
 
  private:
-  bool clear_pending_message_;
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
 class TryFinallyStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
@@ skipping 1997 matching lines @@
                               Statement* then_statement,
                               Statement* else_statement,
                               int pos) {
     return new (local_zone_) IfStatement(local_zone_, condition, then_statement,
                                          else_statement, pos);
   }
 
   TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
                                           Variable* variable,
                                           Block* catch_block, int pos) {
-    return new (local_zone_) TryCatchStatement(
-        local_zone_, try_block, scope, variable, catch_block, true, pos);
+    return new (local_zone_)
+        TryCatchStatement(local_zone_, try_block, scope, variable, catch_block,
+                          HandlerTable::CAUGHT, pos);
   }
 
   TryCatchStatement* NewTryCatchStatementForReThrow(Block* try_block,
                                                     Scope* scope,
                                                     Variable* variable,
                                                     Block* catch_block,
                                                     int pos) {
-    return new (local_zone_) TryCatchStatement(
-        local_zone_, try_block, scope, variable, catch_block, false, pos);
+    return new (local_zone_)
+        TryCatchStatement(local_zone_, try_block, scope, variable, catch_block,
+                          HandlerTable::UNCAUGHT, pos);
+  }
+
+  TryCatchStatement* NewTryCatchStatementForPromiseReject(Block* try_block,
+                                                          Scope* scope,
+                                                          Variable* variable,
+                                                          Block* catch_block,
+                                                          int pos) {
+    return new (local_zone_)
+        TryCatchStatement(local_zone_, try_block, scope, variable, catch_block,
+                          HandlerTable::PROMISE, pos);
   }
 
   TryFinallyStatement* NewTryFinallyStatement(Block* try_block,
                                               Block* finally_block, int pos) {
     return new (local_zone_)
         TryFinallyStatement(local_zone_, try_block, finally_block, pos);
   }
 
   DebuggerStatement* NewDebuggerStatement(int pos) {
     return new (local_zone_) DebuggerStatement(local_zone_, pos);
@@ skipping 362 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_