Do not run async functions with JsBuiltInExecutor

Author: igoriakovlev

runtime/jsMain/src/kotlinx/benchmark/js/JsBenchmarkDescriptorWithAsync.kt

@@ -31,4 +31,10 @@ class JsBenchmarkDescriptorWithBlackholeParameter<T>(
         blackhole: Blackhole,
         function: T.(Blackhole) -> Promise<*>
     ) : this(name, suite, blackhole, function, true)
+}
+
+internal val BenchmarkDescriptor<*>.isAsync get() = when (this) {
+    is JsBenchmarkDescriptorWithNoBlackholeParameter<*> -> async
+    is JsBenchmarkDescriptorWithBlackholeParameter<*> -> async
+    else -> error("Unexpected ${this::class.simpleName}")
 }

runtime/jsMain/src/kotlinx/benchmark/js/JsBenchmarkExecutor.kt

@@ -27,18 +27,13 @@ class JsBenchmarkExecutor(name: String, @Suppress("UNUSED_PARAMETER") dummy_args
         benchmarks.forEach { benchmark ->
             val suite = benchmark.suite
             val config = BenchmarkConfiguration(runnerConfiguration, suite)
-            val isAsync = when (benchmark) {
-                is JsBenchmarkDescriptorWithNoBlackholeParameter -> benchmark.async
-                is JsBenchmarkDescriptorWithBlackholeParameter -> benchmark.async
-                else -> error("Unexpected ${benchmark::class.simpleName}")
-            }
+            val isAsync = benchmark.isAsync
 
             runWithParameters(suite.parameters, runnerConfiguration.params, suite.defaultParameters) { params ->
                 val id = id(benchmark.name, params)
 
                 val instance = suite.factory() // TODO: should we create instance per bench or per suite?
                 suite.parametrize(instance, params)
-
                 val asynchronous = if (isAsync) {
                     when(benchmark) {
                         // Mind asDynamic: this is **not** a regular promise

runtime/jsMain/src/kotlinx/benchmark/js/JsBuiltInExecutor.kt

@@ -14,6 +14,18 @@ class JsBuiltInExecutor(
     private val BenchmarkConfiguration.jsUseBridge: Boolean
         get() = "true".equals(advanced["jsUseBridge"], ignoreCase = true)
 
+    override fun run(
+        runnerConfiguration: RunnerConfiguration,
+        benchmarks: List<BenchmarkDescriptor<Any?>>,
+        start: () -> Unit,
+        complete: () -> Unit
+    ) {
+        if (benchmarks.any { it.isAsync }) {
+            error("${JsBuiltInExecutor::class.simpleName} does not supports async functions")
+        }
+        super.run(runnerConfiguration, benchmarks, start, complete)
+    }
+
     private fun createJsMeasurerBridge(originalMeasurer: () -> Long): () -> Long {
         val bridgeObject = object {
             fun invoke(): Long = originalMeasurer.invoke()