Trigger debug event on not yet caught exception in promises.

src/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 164 matching lines @@
 function PromiseEnqueue(value, tasks) {
   GetMicrotaskQueue().push(function() {
     for (var i = 0; i < tasks.length; i += 2) {
       PromiseHandle(value, tasks[i], tasks[i + 1])
     }
   });
 
   %SetMicrotaskPending(true);
 }
 
+

[rossberg, 2014/04/24 14:33:47]

nit: spurious new line

[Yang, 2014/04/24 14:44:53]

Done.

 function PromiseHandle(value, handler, deferred) {
   try {
     var result = handler(value);
     if (result === deferred.promise)
       throw MakeTypeError('promise_cyclic', [result]);
     else if (IsPromise(result))
       %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain);
     else
       deferred.resolve(result);
-  } catch(e) {
-    // TODO(rossberg): perhaps log uncaught exceptions below.
-    try { deferred.reject(e) } catch(e) {}
+  } catch (exception) {
+    var uncaught = false;
+    if (!IS_SPEC_FUNCTION(deferred.reject)) {

[rossberg, 2014/04/24 14:33:47]

Why do you have to test this case? It will throw in the 'try' below anyway (and
be handled appropriately).

[Yang, 2014/04/24 14:44:53]

Yeah, it will throw, with a TypeError 'undefined is not a function' as
exception. The original exception is then gone. That seems unintuitive.

[rossberg, 2014/04/24 14:56:51]

That may be so, but that's equally true for other errors that could come up from
the call. Not sure why this one justifies an exception (no pun intended). When
delivering to the handler fails I'd say either consistently keep the original
exception, or consistently use the inner one.  (Also, this case probably never
comes up in practice -- and I dislike introducing random special case logic for
cases that don't even matter. ;) )

+      // There is no reject handler defined in the custom deferred promise.
+      // Therefore the exception cannot be caught.
+      uncaught = true;
+    } else {
+      var reject_queue = GET_PRIVATE(deferred.promise, promiseOnReject);
+      if (reject_queue && reject_queue.length == 0) {
+        // The deferred promise may get a reject handler attached later.
+        // For now, we consider the exception to be (for the moment) uncaught.
+        uncaught = true;
+      }
+      try {
+        deferred.reject(exception);
+      } catch (inner_exception) {
+        // The reject handler can only throw for a custom deferred promise.
+        // The resulting exception is considered to be uncaught.
+        uncaught = true;
+        exception = inner_exception;
+      }
+    }
+    if (uncaught) %DebugPendingExceptionInPromise(exception, deferred.promise);
   }
 }
 
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   onResolve =
     IS_NULL_OR_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
   onReject =
@@ skipping 111 matching lines @@
     "resolve", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 }
 
 SetUpPromise();