[JSC] Support Promise.race in async stack trace

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

Reviewed by Yusuke Suzuki.

This patch changes async stack trace to support `Promise.race`.

Test: JSTests/stress/async-stack-trace-promise-race-basic.js
* JSTests/stress/async-stack-trace-promise-race-basic.js: Added.
(nop):
(shouldThrowAsync):
(throw.new.Error.async fine):
(throw.new.Error.async thrower):
(throw.new.Error.async run):
(async task1):
(async task2):
(async task3):
(async run):
(throw.new.Error.async drainMicrotasks):
* Source/JavaScriptCore/builtins/PromiseConstructor.js:
(race):
* Source/JavaScriptCore/interpreter/Interpreter.cpp:
(JSC::Interpreter::getAsyncStackTrace):

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

Author: sosukesuzuki

JSTests/stress/async-stack-trace-promise-race-basic.js

@@ -0,0 +1,117 @@
+//@ requireOptions("--useAsyncStackTrace=1")
+
+const source = "async-stack-trace-promise-race-basic.js";
+
+function nop() {}
+
+function shouldThrowAsync(run, errorType, message, stackFunctions) {
+    let actual;
+    var hadError = false;
+    run().then(
+        function (value) {
+            actual = value;
+        },
+        function (error) {
+            hadError = true;
+            actual = error;
+        },
+    );
+    drainMicrotasks();
+    if (!hadError) {
+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
+    }
+    if (!(actual instanceof errorType)) {
+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
+    }
+    if (message !== void 0 && actual.message !== message) {
+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
+    }
+
+    const stackTrace = actual.stack;
+    if (!stackTrace) {
+        throw new Error("Expected error to have stack trace, but it was undefined");
+    }
+
+    const stackLines = stackTrace.split('\n').filter(line => line.trim());
+
+    for (let i = 0; i < stackFunctions.length; i++) {
+        const [expectedFunction, expectedLocation] = stackFunctions[i];
+        const isNativeCode = expectedLocation === "[native code]" 
+        const stackLine = stackLines[i];
+
+        let found = false;
+
+        if (isNativeCode) {
+            if (stackLine === `${expectedFunction}@[native code]`)
+                found = true;
+        } else {
+            if (stackLine === `${expectedFunction}@${source}:${expectedLocation}`)
+                found = true;
+            if (stackLine === `${expectedFunction}@${source}`)
+                found = true;
+        }
+
+        if (!found) {
+            throw new Error(
+                `Expected stack trace to contain '${expectedFunction}' at '${expectedLocation}', but got '${stackLine}'` +
+                `\nActual stack trace:\n${stackTrace}\n`
+            );
+        }
+    }
+}
+
+{
+  async function fine() { }
+  async function thrower() { await fine(); throw new Error('error'); }
+  async function run() { await Promise.race([thrower()]); }
+
+  for (let i = 0; i < testLoopCount; i++) {
+    shouldThrowAsync(
+      async function test() {
+        await run();
+      }, Error, 'error', [
+        ["thrower", "65:59"],
+        ["async run", "66:44"],
+        ["async test", "71:18"],
+        ["drainMicrotasks", "[native code]"],
+        ["shouldThrowAsync", "19:20"],
+        ["global code", "69:21"]
+      ] 
+    );
+    drainMicrotasks();
+  }
+}
+
+{
+  async function task1() {
+    
+    await nop();
+  
+    throw new Error("error from task1");
+  }
+  async function task2() {
+    await nop();
+
+
+
+    throw new Error('error from task2');
+  }
+  async function task3() { await 1; throw new Error("error from task3"); }
+  async function run() { await Promise.race([task1(), task2(), task3()]); }
+
+  for (let i = 0; i < testLoopCount; i++) {
+    shouldThrowAsync(
+      async function test() {
+        await run();
+      }, Error, 'error from task1' , [
+        ["task1", "90:20"],
+        ["async run", "100:44"],
+        ["async test", "105:18"],
+        ["drainMicrotasks", "[native code]"],
+        ["shouldThrowAsync", "19:20"],
+        ["global code", "103:21"]
+      ]
+    );
+    drainMicrotasks();
+  }
+}

Source/JavaScriptCore/builtins/PromiseConstructor.js

@@ -330,7 +330,11 @@ function race(iterable)
 
         for (var value of iterable) {
             var nextPromise = promiseResolve.@call(this, value);
-            nextPromise.then(resolve, reject);
+            var then = nextPromise.then;
+            if (@isPromise(nextPromise) && then === @defaultPromiseThen)
+                @performPromiseThen(nextPromise, resolve, reject, @undefined, /* context */ promise);
+            else
+                nextPromise.then(resolve, reject);
         }
     } catch (error) {
         reject.@call(@undefined, error);

Source/JavaScriptCore/interpreter/Interpreter.cpp

@@ -497,7 +497,7 @@ void Interpreter::getAsyncStackTrace(JSCell* owner, Vector<StackFrame>& results,
             }
         }
 
-        // handle `Promise.any`
+        // handle `Promise.any` and `Promise.race`
         if (auto* contextPromise = jsDynamicCast<JSPromise*>(promiseContext)) {
             if (JSValue parentContext = getContextValueFromPromise(contextPromise)) {
                 if (auto* generator = jsDynamicCast<JSGenerator*>(parentContext))