HostPromiseRejection tracker:

1. Internal CC machinary for unhandled promise rejection.
2. Simplisitic implimentation in ch
3. Test case

bin/ch/ChakraRtInterface.cpp

@@ -120,6 +120,7 @@ bool ChakraRTInterface::LoadChakraDll(ArgInfo* argInfo, HINSTANCE *outLibrary)
     m_jsApiHooks.pfJsrtGetValueType = (JsAPIHooks::JsrtGetValueType)GetChakraCoreSymbol(library, "JsGetValueType");
     m_jsApiHooks.pfJsrtSetIndexedProperty = (JsAPIHooks::JsrtSetIndexedPropertyPtr)GetChakraCoreSymbol(library, "JsSetIndexedProperty");
     m_jsApiHooks.pfJsrtSetPromiseContinuationCallback = (JsAPIHooks::JsrtSetPromiseContinuationCallbackPtr)GetChakraCoreSymbol(library, "JsSetPromiseContinuationCallback");
+    m_jsApiHooks.pfJsrtSetHostPromiseRejectionTracker = (JsAPIHooks::JsrtSetHostPromiseRejectionTrackerPtr)GetChakraCoreSymbol(library, "JsSetHostPromiseRejectionTracker");
     m_jsApiHooks.pfJsrtGetContextOfObject = (JsAPIHooks::JsrtGetContextOfObject)GetChakraCoreSymbol(library, "JsGetContextOfObject");
     m_jsApiHooks.pfJsrtInitializeModuleRecord = (JsAPIHooks::JsInitializeModuleRecordPtr)GetChakraCoreSymbol(library, "JsInitializeModuleRecord");
     m_jsApiHooks.pfJsrtParseModuleSource = (JsAPIHooks::JsParseModuleSourcePtr)GetChakraCoreSymbol(library, "JsParseModuleSource");

bin/ch/ChakraRtInterface.h

@@ -53,6 +53,7 @@ struct JsAPIHooks
     typedef JsErrorCode (WINAPI *JsrtGetValueType)(JsValueRef value, JsValueType *type);
     typedef JsErrorCode (WINAPI *JsrtSetIndexedPropertyPtr)(JsValueRef object, JsValueRef index, JsValueRef value);
     typedef JsErrorCode (WINAPI *JsrtSetPromiseContinuationCallbackPtr)(JsPromiseContinuationCallback callback, void *callbackState);
+    typedef JsErrorCode (WINAPI *JsrtSetHostPromiseRejectionTrackerPtr)(JsHostPromiseRejectionTrackerCallback callback);
     typedef JsErrorCode (WINAPI *JsrtGetContextOfObject)(JsValueRef object, JsContextRef *callbackState);
 
     typedef JsErrorCode(WINAPI *JsrtDiagStartDebugging)(JsRuntimeHandle runtimeHandle, JsDiagDebugEventCallback debugEventCallback, void* callbackState);
@@ -150,6 +151,7 @@ struct JsAPIHooks
     JsrtGetValueType pfJsrtGetValueType;
     JsrtSetIndexedPropertyPtr pfJsrtSetIndexedProperty;
     JsrtSetPromiseContinuationCallbackPtr pfJsrtSetPromiseContinuationCallback;
+    JsrtSetHostPromiseRejectionTrackerPtr pfJsrtSetHostPromiseRejectionTracker;
     JsrtGetContextOfObject pfJsrtGetContextOfObject;
     JsrtDiagStartDebugging pfJsrtDiagStartDebugging;
     JsrtDiagStopDebugging pfJsrtDiagStopDebugging;
@@ -353,6 +355,7 @@ class ChakraRTInterface
     static JsErrorCode WINAPI JsGetValueType(JsValueRef value, JsValueType *type) { return HOOK_JS_API(GetValueType(value, type)); }
     static JsErrorCode WINAPI JsSetIndexedProperty(JsValueRef object, JsValueRef index, JsValueRef value) { return HOOK_JS_API(SetIndexedProperty(object, index, value)); }
     static JsErrorCode WINAPI JsSetPromiseContinuationCallback(JsPromiseContinuationCallback callback, void *callbackState) { return HOOK_JS_API(SetPromiseContinuationCallback(callback, callbackState)); }
+    static JsErrorCode WINAPI JsSetHostPromiseRejectionTracker(JsHostPromiseRejectionTrackerCallback callback) { return HOOK_JS_API(SetHostPromiseRejectionTracker(callback)); }
     static JsErrorCode WINAPI JsGetContextOfObject(JsValueRef object, JsContextRef* context) { return HOOK_JS_API(GetContextOfObject(object, context)); }
     static JsErrorCode WINAPI JsDiagStartDebugging(JsRuntimeHandle runtimeHandle, JsDiagDebugEventCallback debugEventCallback, void* callbackState) { return HOOK_JS_API(DiagStartDebugging(runtimeHandle, debugEventCallback, callbackState)); }
     static JsErrorCode WINAPI JsDiagStopDebugging(JsRuntimeHandle runtimeHandle, void** callbackState) { return HOOK_JS_API(DiagStopDebugging(runtimeHandle, callbackState)); }

bin/ch/HostConfigFlagsList.h

@@ -15,5 +15,6 @@ FLAG(bool, IgnoreScriptErrorCode,           "Don't return error code on script e
 FLAG(bool, MuteHostErrorMsg,                "Mute host error output, e.g. module load failures", false)
 FLAG(bool, TraceHostCallback,               "Output traces for host callbacks", false)
 FLAG(bool, Test262,                         "load Test262 harness", false)
+FLAG(bool, TrackRejectedPromises,           "Enable tracking of unhandled promise rejections", false)
 #undef FLAG
 #endif

bin/ch/WScriptJsrt.cpp

@@ -1752,3 +1752,19 @@ void WScriptJsrt::PromiseContinuationCallback(JsValueRef task, void *callbackSta
     WScriptJsrt::CallbackMessage *msg = new WScriptJsrt::CallbackMessage(0, task);
     messageQueue->InsertSorted(msg);
 }
+
+void WScriptJsrt::PromiseRejectionTrackerCallback(JsValueRef promise, JsValueRef resolution, bool rejected)
+{
+    Assert(promise != JS_INVALID_REFERENCE);
+    Assert(resolution != JS_INVALID_REFERENCE);
+    if(rejected)
+    {
+        wprintf(_u("Uncaught promise rejection\r\n"));
+    }
+    else
+    {
+        wprintf(_u("Promise rejection handled\r\n"));
+    }
+    fflush(stdout);
+}
+

bin/ch/WScriptJsrt.h

@@ -58,6 +58,7 @@ class WScriptJsrt
     static JsErrorCode NotifyModuleReadyCallback(_In_opt_ JsModuleRecord referencingModule, _In_opt_ JsValueRef exceptionVar);
     static JsErrorCode InitializeModuleCallbacks();
     static void CALLBACK PromiseContinuationCallback(JsValueRef task, void *callbackState);
+    static void CALLBACK PromiseRejectionTrackerCallback(JsValueRef promise, JsValueRef resolution, bool rejected);
 
     static LPCWSTR ConvertErrorCodeToMessage(JsErrorCode errorCode)
     {

bin/ch/ch.cpp

@@ -758,6 +758,10 @@ HRESULT ExecuteTest(const char* fileName)
             IfFailGo(E_FAIL);
         }
 
+        if(HostConfigFlags::flags.TrackRejectedPromises)
+        {
+            ChakraRTInterface::JsSetHostPromiseRejectionTracker(WScriptJsrt::PromiseRejectionTrackerCallback);
+        }
         len = strlen(fullPath);
         if (HostConfigFlags::flags.GenerateLibraryByteCodeHeaderIsEnabled)
         {

lib/Jsrt/ChakraCommon.h

@@ -708,6 +708,21 @@ typedef unsigned short uint16_t;
     /// <param name="callbackState">The data argument to be passed to the callback.</param>
     typedef void (CHAKRA_CALLBACK *JsPromiseContinuationCallback)(_In_ JsValueRef task, _In_opt_ void *callbackState);
 
+    /// <summary>
+    ///     A Promise Rejection Tracker callback.
+    /// </summary>
+    /// <remarks>
+    ///     The host can specify a promise rejection tracker callback in <c>JsSetHostPromiseRejetionTracker</c>.
+    ///     If a promise is rejected with no reactions or a reaction is added to a promise that was rejected
+    ///     before it had reactions by default nothing is done.
+    ///     A Promise Rejection Tracker callback may be set - which will then be called when this occurs.
+    /// </remarks>
+    /// <param name="promise">The promise object, represented as a JsValueRef.</param>
+    /// <param name="resolution">The value/cause of the rejection, represented as a JsValueRef.</param>
+    /// <param name="reject">Boolean - true if the promise has just been rejected with no handler, 
+    ///                         false if it was rejected before without a handler and is now being handled.</param>
+    typedef void (CHAKRA_CALLBACK *JsHostPromiseRejectionTrackerCallback)(_In_ JsValueRef promise, _In_ JsValueRef resolution, _In_ bool reject);
+
     /// <summary>
     ///     Creates a new runtime.
     /// </summary>
@@ -2393,6 +2408,26 @@ typedef unsigned short uint16_t;
             _In_opt_ JsPromiseContinuationCallback promiseContinuationCallback,
             _In_opt_ void *callbackState);
 
+    /// <summary>
+    ///     Sets whether any action should be taken when a promise is rejected with no reactions
+    ///     or a reaction is added to a promise that was rejected before it had reactions.
+    ///     By default in either of these cases nothing occurs.
+    ///     This function allows you to specify if something should occur and provide a callback
+    ///     to implement whatever should occur.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///     Requires an active script context.
+    ///     </para>
+    /// </remarks>
+    /// <param name="callbackState"> The callback function being set.</param>
+    /// <returns>
+    ///     The code <c>JsNoError</c> if the operation succeeded, a failure code otherwise.
+    /// </returns>
+    CHAKRA_API
+        JsSetHostPromiseRejectionTracker(
+            _In_ JsHostPromiseRejectionTrackerCallback promiseRejectionTrackerCallback);
+
 #ifdef _WIN32
 #include "ChakraCommonWindows.h"
 #endif // _WIN32

lib/Jsrt/Jsrt.cpp

@@ -3344,6 +3344,17 @@ CHAKRA_API JsSetPromiseContinuationCallback(_In_opt_ JsPromiseContinuationCallba
     /*allowInObjectBeforeCollectCallback*/true);
 }
 
+CHAKRA_API JsSetHostPromiseRejectionTracker(_In_ JsHostPromiseRejectionTrackerCallback promiseRejectionTrackerCallback)
+{
+    return ContextAPINoScriptWrapper_NoRecord([&](Js::ScriptContext *scriptContext) -> JsErrorCode {
+        scriptContext->GetLibrary()->SetNativeHostPromiseRejectionTrackerCallback((Js::JavascriptLibrary::HostPromiseRejectionTrackerCallback) promiseRejectionTrackerCallback);
+        return JsNoError;
+    },
+    /*allowInObjectBeforeCollectCallback*/true);
+}
+
+
+
 JsErrorCode RunScriptCore(JsValueRef scriptSource, const byte *script, size_t cb,
     LoadScriptFlag loadScriptFlag, JsSourceContext sourceContext,
     const WCHAR *sourceUrl, bool parseOnly, JsParseScriptAttributes parseAttributes,

lib/Jsrt/JsrtCommonExports.inc

@@ -103,6 +103,7 @@
     JsGetRuntime
     JsIdle
     JsSetPromiseContinuationCallback
+    JsSetHostPromiseRejectionTracker
 #ifndef NTBUILD
     JsCreateString
     JsCreateStringUtf16

lib/Runtime/Library/JavascriptLibrary.cpp

@@ -5287,6 +5287,32 @@ namespace Js
         this->nativeHostPromiseContinuationFunctionState = state;
     }
 
+    void JavascriptLibrary::SetNativeHostPromiseRejectionTrackerCallback(HostPromiseRejectionTrackerCallback function)
+    {
+        this->nativeHostPromiseRejectionTracker = function;
+        this->hostShouldTrackPromiseRejections = true;
+    }
+
+    void JavascriptLibrary::CallNativeHostPromiseRejectionTracker(Var promise, Var resolution, bool reject)
+    {
+        if(hostShouldTrackPromiseRejections)
+        {
+            BEGIN_LEAVE_SCRIPT(scriptContext);
+            try
+            {
+               nativeHostPromiseRejectionTracker(promise, resolution, reject);
+            }
+            catch (...)
+            {
+                // Hosts are required not to pass exceptions back across the callback boundary. If
+                // this happens, it is a bug in the host, not something that we are expected to
+                // handle gracefully.
+                Js::Throw::FatalInternalError();
+            }
+            END_LEAVE_SCRIPT(scriptContext);
+        }
+    }
+
     void JavascriptLibrary::SetJsrtContext(FinalizableObject* jsrtContext)
     {
         // With JsrtContext supporting cross context, ensure that it doesn't get GCed

lib/Runtime/Library/JavascriptLibrary.h

@@ -241,6 +241,7 @@ namespace Js
         static DWORD GetRandSeed1Offset() { return offsetof(JavascriptLibrary, randSeed1); }
         static DWORD GetTypeDisplayStringsOffset() { return offsetof(JavascriptLibrary, typeDisplayStrings); }
         typedef bool (CALLBACK *PromiseContinuationCallback)(Var task, void *callbackState);
+        typedef void (CALLBACK *HostPromiseRejectionTrackerCallback)(Var promise, Var resolution, bool rejection);
 
         Var GetUndeclBlockVar() const { return undeclBlockVarSentinel; }
         bool IsUndeclBlockVar(Var var) const { return var == undeclBlockVarSentinel; }
@@ -489,6 +490,9 @@ namespace Js
         FieldNoBarrier(PromiseContinuationCallback) nativeHostPromiseContinuationFunction;
         Field(void *) nativeHostPromiseContinuationFunctionState;
 
+        FieldNoBarrier(HostPromiseRejectionTrackerCallback) nativeHostPromiseRejectionTracker;
+        FieldNoBarrier(bool) hostShouldTrackPromiseRejections = false;
+
         typedef SList<Js::FunctionProxy*, Recycler> FunctionReferenceList;
         typedef JsUtil::WeakReferenceDictionary<uintptr_t, DynamicType, DictionarySizePolicy<PowerOf2Policy, 1>> JsrtExternalTypesCache;
 
@@ -940,6 +944,9 @@ namespace Js
         JavascriptFunction* GetThrowerFunction() const { return throwerFunction; }
 
         void SetNativeHostPromiseContinuationFunction(PromiseContinuationCallback function, void *state);
+        void SetNativeHostPromiseRejectionTrackerCallback(HostPromiseRejectionTrackerCallback function);
+        void CallNativeHostPromiseRejectionTracker(Var promise, Var resolution, bool reject);
+
 
         void SetJsrtContext(FinalizableObject* jsrtContext);
         FinalizableObject* GetJsrtContext();

lib/Runtime/Library/JavascriptPromise.cpp

@@ -12,6 +12,7 @@ namespace Js
         Assert(type->GetTypeId() == TypeIds_Promise);
 
         this->status = PromiseStatusCode_Undefined;
+        this->isHandled = false;
         this->result = nullptr;
         this->resolveReactions = nullptr;
         this->rejectReactions = nullptr;
@@ -660,6 +661,10 @@ namespace Js
         {
             reactions = this->GetRejectReactions();
             newStatus = PromiseStatusCode_HasRejection;
+            if(!GetIsHandled()) //TO DO - find a way to make "await" calls evaluate to false here
+            {
+                scriptContext->GetLibrary()->CallNativeHostPromiseRejectionTracker(this, resolution, true);
+            }
         }
         else
         {
@@ -838,13 +843,19 @@ namespace Js
             EnqueuePromiseReactionTask(resolveReaction, sourcePromise->result, scriptContext);
             break;
         case PromiseStatusCode_HasRejection:
+            if(!sourcePromise->GetIsHandled())
+            {
+                scriptContext->GetLibrary()->CallNativeHostPromiseRejectionTracker(sourcePromise, sourcePromise->result, false);
+            }
             EnqueuePromiseReactionTask(rejectReaction, sourcePromise->result, scriptContext);
             break;
         default:
             AssertMsg(false, "Promise status is in an invalid state");
             break;
         }
 
+        sourcePromise->SetIsHandled();
+
         return promiseCapability->GetPromise();
     }
 
@@ -1007,7 +1018,7 @@ namespace Js
         reject = args[2];
 
         Assert(JavascriptPromiseAsyncSpawnExecutorFunction::Is(function));
-        JavascriptPromiseAsyncSpawnExecutorFunction* asyncSpawnExecutorFunction = JavascriptPromiseAsyncSpawnExecutorFunction::FromVar(function);
+        JavascriptPromiseAsyncSpawnExecutorFunction* asyncSpawnExecutorFunction = JavascriptPromiseAsyncSpawnExecutorFunction::FromVar(function);        
         Var self = asyncSpawnExecutorFunction->GetTarget();
 
         Var varCallArgs[] = { undefinedVar, self };

lib/Runtime/Library/JavascriptPromise.h

@@ -461,6 +461,8 @@ namespace Js
             PromiseStatusCode_HasRejection
         };
 
+        bool GetIsHandled() {return isHandled;}
+        void SetIsHandled() {isHandled = true;}
         PromiseStatus GetStatus() const { return status; }
         Var GetResult() const { return result; }
 
@@ -470,6 +472,7 @@ namespace Js
     protected:
         Field(PromiseStatus) status;
         Field(Var) result;
+        Field(bool) isHandled;
         Field(JavascriptPromiseReactionList*) resolveReactions;
         Field(JavascriptPromiseReactionList*) rejectReactions;
 

test/es7/PromiseRejectionTracking.baseline

@@ -0,0 +1,19 @@
+Executing test #1 - Reject promise with no reactions.
+Uncaught promise rejection
+Executing test #2 - Reject promise with a catch reaction only.
+Executing test #3 - Reject promise with catch and then reactions.
+Executing test #4 - Reject promise then add  a catch afterwards.
+Uncaught promise rejection
+Promise rejection handled
+Executing test #5 - Reject promise then add two catches afterwards.
+Uncaught promise rejection
+Promise rejection handled
+Executing test #6 - Async function that throws.
+Uncaught promise rejection
+Executing test #7 - Async function that throws but is caught.
+Uncaught promise rejection
+Promise rejection handled
+Executing test #8 - Async function that awaits a function that throws.
+Uncaught promise rejection
+Promise rejection handled
+Uncaught promise rejection