[debug] Don't notify listener of exceptions internal to a desugaring.

src/isolate.cc

 // 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.
 
 #include "src/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 1124 matching lines @@
     } else {
       Handle<Object> message_obj = CreateMessage(exception_handle, location);
       thread_local_top()->pending_message_obj_ = *message_obj;
 
       // For any exception not caught by JavaScript, even when an external
       // handler is present:
       // If the abort-on-uncaught-exception flag is specified, and if the
       // embedder didn't specify a custom uncaught exception callback,
       // or if the custom callback determined that V8 should abort, then
       // abort.
+      CatchType prediction = PredictExceptionCatcher();
       if (FLAG_abort_on_uncaught_exception &&
-          PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT &&
+          (prediction == NOT_CAUGHT || prediction == CAUGHT_BY_EXTERNAL) &&
           (!abort_on_uncaught_exception_callback_ ||
            abort_on_uncaught_exception_callback_(
                reinterpret_cast<v8::Isolate*>(this)))) {
         // Prevent endless recursion.
         FLAG_abort_on_uncaught_exception = false;
         // This flag is intended for use by JavaScript developers, so
         // print a user-friendly stack trace (not an internal one).
         PrintF(stderr, "%s\n\nFROM\n",
                MessageHandler::GetLocalizedMessage(this, message_obj).get());
         PrintCurrentStackTrace(stderr);
@@ skipping 175 matching lines @@
     StackFrame* frame = iter.frame();
 
     // For JSEntryStub frames we update the JS_ENTRY handler.
     if (frame->is_entry() || frame->is_entry_construct()) {
       entry_handler = frame->top_handler()->next()->address();
     }
 
     // For JavaScript frames we perform a lookup in the handler table.
     if (frame->is_java_script()) {
       JavaScriptFrame* js_frame = static_cast<JavaScriptFrame*>(frame);
-      if (PredictException(js_frame) != HandlerTable::UNCAUGHT) {
-        return CAUGHT_BY_JAVASCRIPT;
-      }
+      HandlerTable::CatchPrediction prediction = PredictException(js_frame);
+      if (prediction == HandlerTable::DESUGARING) return CAUGHT_BY_DESUGARING;
+      if (prediction != HandlerTable::UNCAUGHT) return CAUGHT_BY_JAVASCRIPT;
     }
 
     // The exception has been externally caught if and only if there is an
     // external handler which is on top of the top-most JS_ENTRY handler.
     if (external_handler != nullptr && !try_catch_handler()->is_verbose_) {
       if (entry_handler == nullptr || entry_handler > external_handler) {
         return CAUGHT_BY_EXTERNAL;
       }
     }
   }
@@ skipping 388 matching lines @@
   tltop->promise_on_stack_ = prev;
   global_handles()->Destroy(global_promise.location());
 }
 
 
 Handle<Object> Isolate::GetPromiseOnStackOnThrow() {
   Handle<Object> undefined = factory()->undefined_value();
   ThreadLocalTop* tltop = thread_local_top();
   if (tltop->promise_on_stack_ == NULL) return undefined;
   // Find the top-most try-catch or try-finally handler.
-  if (PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT) return undefined;
+  CatchType prediction = PredictExceptionCatcher();
+  if (prediction == NOT_CAUGHT || prediction == CAUGHT_BY_EXTERNAL) {
+    return undefined;
+  }
   for (JavaScriptFrameIterator it(this); !it.done(); it.Advance()) {
     switch (PredictException(it.frame())) {
       case HandlerTable::UNCAUGHT:
         break;
       case HandlerTable::CAUGHT:
+      case HandlerTable::DESUGARING:
         return undefined;
       case HandlerTable::PROMISE:
         return tltop->promise_on_stack_->promise();
     }
   }
   return undefined;
 }
 
 
 void Isolate::SetCaptureStackTraceForUncaughtExceptions(
@@ skipping 1430 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8