Synchronous path changes

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 1301 matching lines @@
     // 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);
       HandlerTable::CatchPrediction prediction = PredictException(js_frame);
       if (prediction == HandlerTable::DESUGARING) return CAUGHT_BY_DESUGARING;
+      if (prediction == HandlerTable::ASYNC_AWAIT) return CAUGHT_BY_ASYNC_AWAIT;
       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 386 matching lines @@
 void Isolate::PopPromise() {
   ThreadLocalTop* tltop = thread_local_top();
   if (tltop->promise_on_stack_ == NULL) return;
   PromiseOnStack* prev = tltop->promise_on_stack_->prev();
   Handle<Object> global_promise = tltop->promise_on_stack_->promise();
   delete tltop->promise_on_stack_;
   tltop->promise_on_stack_ = prev;
   global_handles()->Destroy(global_promise.location());
 }
 
+bool Isolate::PromiseHasUserDefinedRejectHandler(Handle<JSObject> promise) {
+  Handle<JSFunction> fun = promise_has_user_defined_reject_handler();
+  Handle<Object> has_reject_handler;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(this, has_reject_handler,
+                                   Execution::Call(this, fun, promise, 0, NULL),
+                                   false);
+  return has_reject_handler->IsTrue(this);
+}
 
 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.
   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();
+      case HandlerTable::ASYNC_AWAIT: {
+        // If in an async/await, pop up successive async/await stack frames
+        // until an asynchronous one with dependents is found, or a non-async
+        // stack frame is encountered, in order to handle the synchronous
+        // async/await catch prediction case: assume that async function calls
+        // are awaited.
+        PromiseOnStack* promise_on_stack = tltop->promise_on_stack_;
+        for (it.Advance(); !it.done(); it.Advance()) {
+          if (PromiseHasUserDefinedRejectHandler(promise_on_stack->promise())) {
+            break;
+          }
+          JavaScriptFrame* frame = it.frame();
+          if (!frame->function()->shared()->is_async()) {
+            // Keep searching up the stack until an async function stack frame
+            // is found, heuristically assuming that that will ultimately await
+            // whatever is going on here.
+            continue;
+          }
+          PromiseOnStack* next_promise_on_stack = promise_on_stack->prev();
+          if (next_promise_on_stack == nullptr) break;
+          switch (PredictException(it.frame())) {
+            case HandlerTable::CAUGHT:
+            case HandlerTable::DESUGARING: {
+              // Mark the inner promise as caught in the "synchronous case" so
+              // that Debug::OnException will see.
+              Handle<Symbol> key = factory()->promise_handled_hint_symbol();
+              JSObject::SetProperty(promise_on_stack->promise(), key, key,
+                                    STRICT)
+                  .Assert();
+              return promise_on_stack->promise();
+            }
+            case HandlerTable::ASYNC_AWAIT:
+              promise_on_stack = next_promise_on_stack;
+              continue;
+            case HandlerTable::PROMISE:
+            case HandlerTable::UNCAUGHT:
+              UNREACHABLE();
+          }
+        }
+        return promise_on_stack->promise();
+      }
     }
   }
   return undefined;
 }
 
 
 void Isolate::SetCaptureStackTraceForUncaughtExceptions(
       bool capture,
       int frame_limit,
       StackTrace::StackTraceOptions options) {
@@ skipping 1422 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8