sjsJUnitTest: copy-paste PromiseMock from scala.js upstream

To improve our testing of unions until we get a release of Scala.js with
the fixed PromiseMock. This also lets us re-enable AsyncTest which
depends on PromiseMock.

Author: smarter

project/Build.scala

@@ -1105,7 +1105,8 @@ object Build {
             -- "ObjectTest.scala" // compile errors caused by #9588
             -- "StackTraceTest.scala" // would require `npm install source-map-support`
             -- "UnionTypeTest.scala" // requires the Scala 2 macro defined in Typechecking*.scala
-            -- "PromiseMock.scala" -- "AsyncTest.scala" // TODO: Enable once we use a Scala.js with https://github.com/scala-js/scala-js/pull/4451 in
+            -- "PromiseMock.scala" // TODO: Enable once we use a Scala.js with https://github.com/scala-js/scala-js/pull/4451 in
+                                   // and remove copy in tests/sjs-junit
             )).get
 
           ++ (dir / "js/src/test/require-2.12" ** (("*.scala": FileFilter)

tests/sjs-junit/test/org/scalajs/testsuite/jsinterop/PromiseMock.scala

@@ -0,0 +1,260 @@
+/*
+ * Scala.js (https://www.scala-js.org/)
+ *
+ * Copyright EPFL.
+ *
+ * Licensed under Apache License 2.0
+ * (https://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package org.scalajs.testsuite.jsinterop
+
+import scala.scalajs.js
+import scala.scalajs.js.annotation._
+import scala.scalajs.js.|
+
+import js.Thenable
+
+object PromiseMock {
+
+  @noinline
+  def withMockedPromise[A](body: (() => Unit) => A): A = {
+    val global = org.scalajs.testsuite.utils.JSUtils.globalObject
+
+    val oldPromise =
+      if (global.hasOwnProperty("Promise").asInstanceOf[Boolean]) Some(global.Promise)
+      else None
+
+    global.Promise = js.constructorOf[MockPromise[_]]
+    try {
+      body(MockPromise.processQueue _)
+    } finally {
+      oldPromise.fold {
+        js.special.delete(global, "Promise")
+      } { old =>
+        global.Promise = old
+      }
+    }
+  }
+
+  @noinline
+  def withMockedPromiseIfExists[A](body: (Option[() => Unit]) => A): A = {
+    val global = org.scalajs.testsuite.utils.JSUtils.globalObject
+
+    val oldPromise = global.Promise
+
+    if (js.isUndefined(oldPromise)) {
+      body(None)
+    } else {
+      global.Promise = js.constructorOf[MockPromise[_]]
+      try {
+        body(Some(MockPromise.processQueue _))
+      } finally {
+        global.Promise = oldPromise
+      }
+    }
+  }
+
+  private object MockPromise {
+    private val queue = js.Array[js.Function0[Any]]()
+
+    @JSExportStatic
+    def resolve[A](value: A | js.Thenable[A]): MockPromise[A] = {
+      new MockPromise[A]({
+        (resolve: js.Function1[A | js.Thenable[A], _],
+            reject: js.Function1[Any, _]) =>
+          resolve(value)
+      })
+    }
+
+    @JSExportStatic
+    def reject(reason: Any): MockPromise[Nothing] = {
+      new MockPromise[Nothing]({
+        (resolve: js.Function1[Nothing | js.Thenable[Nothing], _],
+            reject: js.Function1[Any, _]) =>
+          reject(reason)
+      })
+    }
+
+    def enqueue(f: js.Function0[Any]): Unit =
+      queue.push(f)
+
+    def processQueue(): Unit = {
+      while (queue.nonEmpty)
+        queue.shift()()
+    }
+
+    private sealed abstract class State[+A]
+
+    private case object Pending extends State[Nothing]
+    private case class Fulfilled[+A](value: A) extends State[A]
+    private case class Rejected(reason: Any) extends State[Nothing]
+
+    private def isNotAnObject(x: Any): Boolean = x match {
+      case null | () | _:Double | _:Boolean | _:String => true
+      case _                                           => false
+    }
+
+    private def isCallable(x: Any): Boolean =
+      js.typeOf(x.asInstanceOf[js.Any]) == "function"
+
+    private def throwAny(e: Any): Nothing = {
+      throw (e match {
+        case th: Throwable => th
+        case _             => js.JavaScriptException(e)
+      })
+    }
+
+    private def tryCatchAny[A](tryBody: => A)(catchBody: Any => A): A = {
+      try {
+        tryBody
+      } catch {
+        case th: Throwable =>
+          catchBody(th match {
+            case js.JavaScriptException(e) => e
+            case _                         => th
+          })
+      }
+    }
+  }
+
+  private class MockPromise[+A](
+      executor: js.Function2[js.Function1[A | Thenable[A], _], js.Function1[scala.Any, _], _])
+      extends js.Object with js.Thenable[A] {
+
+    import MockPromise._
+
+    private[this] var state: State[A] = Pending
+
+    private[this] var fulfillReactions = js.Array[js.Function1[A, Any]]()
+    private[this] var rejectReactions = js.Array[js.Function1[Any, Any]]()
+
+    init(executor)
+
+    // 25.4.3.1 Promise(executor)
+    private[this] def init(
+        executor: js.Function2[js.Function1[A | Thenable[A], _], js.Function1[scala.Any, _], _]) = {
+      tryCatchAny[Unit] {
+        executor(resolve _, reject _)
+      } { e =>
+        reject(e)
+      }
+    }
+
+    private[this] def fulfill(value: A): Unit = {
+      assert(state == Pending)
+      state = Fulfilled(value)
+      clearAndTriggerReactions(fulfillReactions, value)
+    }
+
+    private[this] def clearAndTriggerReactions[A](
+        reactions: js.Array[js.Function1[A, Any]],
+        argument: A): Unit = {
+
+      assert(state != Pending)
+
+      fulfillReactions = null
+      rejectReactions = null
+
+      for (reaction <- reactions)
+        enqueue(() => reaction(argument))
+    }
+
+    // 25.4.1.3.2 Promise Resolve Functions
+    private[this] def resolve(resolution: A | Thenable[A]): Unit = {
+      if (state == Pending) {
+        if (resolution.asInstanceOf[AnyRef] eq this) {
+          reject(new js.TypeError("Self resolution"))
+        } else if (isNotAnObject(resolution)) {
+          fulfill(resolution.asInstanceOf[A])
+        } else {
+          tryCatchAny {
+            val thenAction = resolution.asInstanceOf[js.Dynamic].`then`
+            if (!isCallable(thenAction)) {
+              fulfill(resolution.asInstanceOf[A])
+            } else {
+              val thenable = resolution.asInstanceOf[Thenable[A]]
+              val thenActionFun = thenAction.asInstanceOf[js.Function]
+              enqueue(() => promiseResolveThenableJob(thenable, thenActionFun))
+            }
+          } { e =>
+            reject(e)
+          }
+        }
+      }
+    }
+
+    // 25.4.2.2 PromiseResolveThenableJob
+    private[this] def promiseResolveThenableJob(thenable: Thenable[A],
+        thenAction: js.Function): Unit = {
+      thenAction.call(thenable, resolve _, reject _)
+    }
+
+    // 25.4.1.3.1 Promise Reject Functions
+    private[this] def reject(reason: Any): Unit = {
+      if (state == Pending) {
+        state = Rejected(reason)
+        clearAndTriggerReactions(rejectReactions, reason)
+      }
+    }
+
+    // 25.4.5.3 Promise.prototype.then
+    def `then`[B](
+        onFulfilled: js.Function1[A, B | Thenable[B]],
+        onRejected: js.UndefOr[js.Function1[scala.Any, B | Thenable[B]]]): MockPromise[B] = {
+
+      new MockPromise[B](
+        { (innerResolve: js.Function1[B | Thenable[B], _],
+            innerReject: js.Function1[scala.Any, _]) =>
+
+          def doFulfilled(value: A): Unit = {
+            tryCatchAny[Unit] {
+              innerResolve(onFulfilled(value))
+            } { e =>
+              innerReject(e)
+            }
+          }
+
+          def doRejected(reason: Any): Unit = {
+            tryCatchAny[Unit] {
+              onRejected.fold[Unit] {
+                innerReject(reason)
+              } { onRejectedFun =>
+                innerResolve(onRejectedFun(reason))
+              }
+            } { e =>
+              innerReject(e)
+            }
+          }
+
+          state match {
+            case Pending =>
+              fulfillReactions += doFulfilled _
+              rejectReactions += doRejected _
+
+            case Fulfilled(value) =>
+              enqueue(() => doFulfilled(value))
+
+            case Rejected(reason) =>
+              enqueue(() => doRejected(reason))
+          }
+        }
+      )
+    }
+
+    def `then`[B >: A](
+        onFulfilled: Unit,
+        onRejected: js.UndefOr[js.Function1[scala.Any, B | Thenable[B]]]): MockPromise[B] = {
+      `then`((x: A) => (x: B | Thenable[B]), onRejected)
+    }
+
+    // 25.4.5.1 Promise.prototype.catch
+    def `catch`[B >: A](
+        onRejected: js.UndefOr[js.Function1[scala.Any, B | Thenable[B]]]): MockPromise[B] = {
+      `then`((), onRejected)
+    }
+  }
+}