[JSC] Implement Promise.try

https://bugs.webkit.org/show_bug.cgi?id=269775

Reviewed by Justin Michaud.

This patch implements https://github.com/tc39/proposal-promise-try behind a runtime option;
the proposal is currently at Stage 2 but the spec is very simple and not expected to change.

Effectively, Promise.try(f) is a more convenient way to write `new Promise((resolve) => { resolve(f()); })` --
we don't care whether f is sync or async, but if is synchronous, we want it to be executed immediately.

This implementation includes tc39/proposal-promise-try#16, which the champion expects to merge;
it simply extends the API to Promise.try(f, ...args) such that arguments can be forwarded to the callback.

* JSTests/stress/promise-try.js: Added.
* Source/JavaScriptCore/builtins/PromiseConstructor.js:
(try): Added.
* Source/JavaScriptCore/runtime/JSPromiseConstructor.cpp:
(JSC::JSPromiseConstructor::finishCreation):
* Source/JavaScriptCore/runtime/OptionsList.h:

Canonical link: https://commits.webkit.org/275081@main

JSTests/stress/promise-try.js

@@ -0,0 +1,52 @@
+//@ requireOptions("--usePromiseTryMethod=1")
+
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`expected ${expected} but got ${actual}`);
+}
+
+function notReached() {
+    throw new Error('should not reach here');
+}
+
+async function delay() {
+    return new Promise((resolve, reject) => {
+        setTimeout(resolve);
+    });
+}
+
+shouldBe(Promise.try.length, 1);
+
+async function test() {
+    {
+        let result = [];
+        Promise.try(() => { result.push(1); });
+        result.push(2);
+        await delay();
+        shouldBe(`${result}`, '1,2');
+    }
+
+    shouldBe(await Promise.try(() => Promise.resolve(3)), 3);
+
+    try {
+        await Promise.try(() => { throw 4; });
+        notReached();
+    } catch (e) {
+        shouldBe(e, 4);
+    }
+
+    try {
+        await Promise.try(() => Promise.reject(5));
+        notReached();
+    } catch (e) {
+        shouldBe(e, 5);
+    }
+
+    shouldBe(await Promise.try((x, y, z) => x + y + z, 1, 2, 3), 6);
+}
+
+test().catch((error) => {
+    print(`FAIL: ${error}\n${error.stack}`);
+    $vm.abort();
+});
+drainMicrotasks();

Source/JavaScriptCore/builtins/PromiseConstructor.js

@@ -368,6 +368,28 @@ function resolve(value)
     return @promiseResolve(this, value);
 }
 
+function try(callback /*, ...args */)
+{
+    "use strict";
+
+    if (!@isObject(this))
+        @throwTypeError("|this| is not an object");
+
+    var args = [];
+    for (var i = 1; i < arguments.length; i++)
+        @putByValDirect(args, i - 1, arguments[i]);
+
+    var promiseCapability = @newPromiseCapability(this);
+    try {
+        var value = callback.@apply(@undefined, args);
+        promiseCapability.resolve.@call(@undefined, value);
+    } catch (error) {
+        promiseCapability.reject.@call(@undefined, error);
+    }
+
+    return promiseCapability.promise;
+}
+
 function withResolvers()
 {
     "use strict";

Source/JavaScriptCore/runtime/JSPromiseConstructor.cpp

@@ -88,6 +88,8 @@ void JSPromiseConstructor::finishCreation(VM& vm, JSPromisePrototype* promisePro
 
     if (Options::usePromiseWithResolversMethod())
         JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->builtinNames().withResolversPublicName(), promiseConstructorWithResolversCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));
+    if (Options::usePromiseTryMethod())
+        JSC_BUILTIN_FUNCTION_WITHOUT_TRANSITION(vm.propertyNames->tryKeyword, promiseConstructorTryCodeGenerator, static_cast<unsigned>(PropertyAttribute::DontEnum));
 }
 
 void JSPromiseConstructor::addOwnInternalSlots(VM& vm, JSGlobalObject* globalObject)

Source/JavaScriptCore/runtime/OptionsList.h

@@ -589,6 +589,7 @@ bool canUseHandlerIC();
     v(Bool, useImportAttributes, true, Normal, "Enable import attributes.") \
     v(Bool, useIntlDurationFormat, true, Normal, "Expose the Intl DurationFormat.") \
     v(Bool, usePromiseWithResolversMethod, true, Normal, "Expose the Promise.withResolvers() method.") \
+    v(Bool, usePromiseTryMethod, false, Normal, "Expose the Promise.try() method.") \
     v(Bool, useResizableArrayBuffer, true, Normal, "Expose ResizableArrayBuffer feature.") \
     v(Bool, useSharedArrayBuffer, false, Normal, nullptr) \
     v(Bool, useShadowRealm, false, Normal, "Expose the ShadowRealm object.") \