Enable R8 optimization of Dispatchers.Main loading

kotlinx-coroutines-core/jvm/src/CoroutineExceptionHandlerImpl.kt

@@ -13,10 +13,15 @@ import kotlin.coroutines.*
  * Note that Android may have dummy [Thread.contextClassLoader] which is used by one-argument [ServiceLoader.load] function,
  * see (https://stackoverflow.com/questions/13407006/android-class-loader-may-fail-for-processes-that-host-multiple-applications).
  * So here we explicitly use two-argument `load` with a class-loader of [CoroutineExceptionHandler] class.
+ *
+ * We are explicitly using the `ServiceLoader.load(MyClass::class.java, MyClass::class.java.classLoader).iterator()`
+ * form of the ServiceLoader call to enable R8 optimization when compiled on Android.
  */
-private val handlers: List<CoroutineExceptionHandler> = CoroutineExceptionHandler::class.java.let { serviceClass ->
-    ServiceLoader.load(serviceClass, serviceClass.classLoader).toList()
-}
+private val handlers: List<CoroutineExceptionHandler> = ServiceLoader.load(
+        CoroutineExceptionHandler::class.java,
+        CoroutineExceptionHandler::class.java.classLoader
+).iterator().asSequence().toList()
+
 
 internal actual fun handleCoroutineExceptionImpl(context: CoroutineContext, exception: Throwable) {
     // use additional extension handlers

kotlinx-coroutines-core/jvm/src/internal/FastServiceLoader.kt

@@ -6,11 +6,6 @@ import java.util.*
 import java.util.jar.*
 import java.util.zip.*
 
-/**
- * Name of the boolean property that enables using of [FastServiceLoader].
- */
-private const val FAST_SERVICE_LOADER_PROPERTY_NAME = "kotlinx.coroutines.fast.service.loader"
-
 /**
  * A simplified version of [ServiceLoader].
  * FastServiceLoader locates and instantiates all service providers named in configuration
@@ -25,12 +20,7 @@ private const val FAST_SERVICE_LOADER_PROPERTY_NAME = "kotlinx.coroutines.fast.s
 internal object FastServiceLoader {
     private const val PREFIX: String = "META-INF/services/"
 
-    private val FAST_SERVICE_LOADER_ENABLED = systemProp(FAST_SERVICE_LOADER_PROPERTY_NAME, true)
-
     internal fun <S> load(service: Class<S>, loader: ClassLoader): List<S> {
-        if (!FAST_SERVICE_LOADER_ENABLED) {
-            return ServiceLoader.load(service, loader).toList()
-        }
         return try {
             loadProviders(service, loader)
         } catch (e: Throwable) {

kotlinx-coroutines-core/jvm/src/internal/MainDispatchers.kt

@@ -4,15 +4,33 @@ import kotlinx.coroutines.*
 import java.util.*
 import kotlin.coroutines.*
 
+/**
+ * Name of the boolean property that enables using of [FastServiceLoader].
+ */
+private const val FAST_SERVICE_LOADER_PROPERTY_NAME = "kotlinx.coroutines.fast.service.loader"
+
 // Lazy loader for the main dispatcher
 internal object MainDispatcherLoader {
+
+    private val FAST_SERVICE_LOADER_ENABLED = systemProp(FAST_SERVICE_LOADER_PROPERTY_NAME, true)
+
     @JvmField
     val dispatcher: MainCoroutineDispatcher = loadMainDispatcher()
 
     private fun loadMainDispatcher(): MainCoroutineDispatcher {
         return try {
-            val factories = MainDispatcherFactory::class.java.let { clz ->
-                FastServiceLoader.load(clz, clz.classLoader)
+            val factories = if (FAST_SERVICE_LOADER_ENABLED) {
+                MainDispatcherFactory::class.java.let { clz ->
+                    FastServiceLoader.load(clz, clz.classLoader)
+                }
+            } else {
+                //We are explicitly using the
+                //`ServiceLoader.load(MyClass::class.java, MyClass::class.java.classLoader).iterator()`
+                //form of the ServiceLoader call to enable R8 optimization when compiled on Android.
+                ServiceLoader.load(
+                        MainDispatcherFactory::class.java,
+                        MainDispatcherFactory::class.java.classLoader
+                ).iterator().asSequence().toList()
             }
             factories.maxBy { it.loadPriority }?.tryCreateDispatcher(factories)
                 ?: MissingMainCoroutineDispatcher(null)