Merge branch 'release-candidate' into develop

# Conflicts:
#	core/kotlinx-coroutines-core/test/RunBlockingTest.kt
#	docs/coroutine-context-and-dispatchers.md

Author: qwwdfsad

CHANGES.md

@@ -74,9 +74,9 @@ Visible consequences of include more robust exception handling for large corouti
   * All coroutine builders are now extensions on `CoroutineScope` and inherit its `coroutineContext`. Standalone builders are deprecated.
   * As a consequence, all nested coroutines launched via builders now automatically establish parent-child relationship and inherit `CoroutineDispatcher`.
   * All coroutine builders use `Dispatchers.Default` by default if `CoroutineInterceptor` is not present in their context.
-  * [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-scope/) became the first-class citizen in `kolinx.coroutines`.
+  * [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/) became the first-class citizen in `kolinx.coroutines`.
   * `withContext` `block` argument has `CoroutineScope` as a receiver.
-  * [GlobalScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-global-scope/) is introduced to simplify migration to new API and to launch global-level coroutines.
+  * [GlobalScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-global-scope/) is introduced to simplify migration to new API and to launch global-level coroutines.
   * `currentScope` and `coroutineScope` builders are introduced to extract and provide `CoroutineScope`.
   * Factory methods to create `CoroutineScope` from `CoroutineContext` are introduced.
   * `CoroutineScope.isActive` became an extension property.
@@ -604,7 +604,7 @@ Visible consequences of include more robust exception handling for large corouti
 ## Version 0.11-rc
 
 * `select` expression with onJoin/onAwait/onSend/onReceive clauses.
-* `Mutex` is moved to `kotlinx.coroutines.experimental.sync` package.
+* `Mutex` is moved to `kotlinx.coroutines.sync` package.
 * `ClosedSendChannelException` is a subclass of `CancellationException` now.
 * New sections on "Shared mutable state and concurrency" and "Select expression" 
   in [coroutines guide](docs/coroutines-guide.md).

README.md

@@ -5,7 +5,7 @@
 [![Download](https://api.bintray.com/packages/kotlin/kotlinx/kotlinx.coroutines/images/download.svg?version=0.30.2) ](https://bintray.com/kotlin/kotlinx/kotlinx.coroutines/0.30.2)
 
 Library support for Kotlin coroutines with [multiplatform](#multiplatform) support.
-This is a companion version for Kotlin 1.2.70 release.
+This is a companion version for Kotlin 1.3.0-rc-146 release.
 
 **NOTE**: This is the _last_ experimental feature release. 
 See [COMPATIBILITY.md](COMPATIBILITY.md) for details of migration onto the stable Kotlin 1.3 coroutines.
@@ -70,33 +70,35 @@ Add dependencies (you can also add other modules that you need):
 <dependency>
     <groupId>org.jetbrains.kotlinx</groupId>
     <artifactId>kotlinx-coroutines-core</artifactId>
-    <version>0.30.2</version>
+    <version>0.30.2-eap13</version>
 </dependency>
 ```
 
 And make sure that you use the latest Kotlin version:
 
 ```xml
 <properties>
-    <kotlin.version>1.2.70</kotlin.version>
+    <kotlin.version>1.3.0-rc-146</kotlin.version>
 </properties>
 ```
 
+While Kotlin 1.3 is still in release candidate status, in order to depend on it you should add eap repository: `https://dl.bintray.com/kotlin/kotlin-eap`.
+
 ### Gradle
 
 Add dependencies (you can also add other modules that you need):
 
 ```groovy
 dependencies {
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.2'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.2-eap13'
 }
 ```
 
 And make sure that you use the latest Kotlin version:
 
 ```groovy
 buildscript {
-    ext.kotlin_version = '1.2.70'
+    ext.kotlin_version = '1.3.0-rc-146'
 }
 ```
 
@@ -148,24 +150,16 @@ Add [`kotlinx-coroutines-android`](ui/kotlinx-coroutines-android)
 module as dependency when using `kotlinx.coroutines` on Android:
 
 ```groovy
-implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.2'
+implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.2-eap13'
 ```
-This gives you access to Android [Dispatchers.Main](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-android/kotlinx.coroutines.experimental.android/kotlinx.coroutines.experimental.-dispatchers/index.html)
+This gives you access to Android [Dispatchers.Main](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-android/kotlinx.coroutines.android/kotlinx.coroutines.-dispatchers/index.html)
 coroutine dispatcher and also makes sure that in case of crashed coroutine with unhandled exception this
 exception is logged before crashing Android application, similarly to the way uncaught exceptions in 
 threads are handled by Android runtime. 
 
-### ProGuard
-
-In obfuscated code, fields with different types can have the same names,
-and `AtomicReferenceFieldUpdater` may be unable to find the correct ones.
-To avoid field overloading by type during obfuscation, add this to your config:
+### R8 and ProGuard
 
-```
--keepclassmembernames class kotlinx.** {
-    volatile <fields>;
-}
-```
+If you are using R8 or ProGuard add the options from [coroutines.pro](core/kotlinx-coroutines-core/resources/META-INF/proguard/coroutines.pro) file to your rules.
 
 ## Building 
 

benchmarks/src/jmh/kotlin/benchmarks/CancellableContinuationBenchmark.kt

@@ -4,11 +4,11 @@
 
 package benchmarks
 
-import kotlinx.coroutines.experimental.*
+import kotlinx.coroutines.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
-import kotlin.coroutines.experimental.*
-import kotlin.coroutines.experimental.intrinsics.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 @Warmup(iterations = 5)
 @Measurement(iterations = 10)
@@ -47,10 +47,7 @@ open class CancellableContinuationBenchmark {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 
-        override fun resume(value: Int) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
+        override fun resumeWith(result: Result<Int>) {
         }
     }
 }

benchmarks/src/jmh/kotlin/benchmarks/ChannelSinkBenchmark.kt

@@ -4,29 +4,49 @@
 
 package benchmarks
 
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.channels.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
-import kotlin.coroutines.experimental.*
+import kotlin.coroutines.*
 
-@Warmup(iterations = 10, time = 1)
-@Measurement(iterations = 10, time = 1)
+@Warmup(iterations = 5, time = 1)
+@Measurement(iterations = 5, time = 1)
 @BenchmarkMode(Mode.AverageTime)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
 @State(Scope.Benchmark)
-@Fork(2)
+@Fork(1)
 open class ChannelSinkBenchmark {
+    private val tl = ThreadLocal.withInitial({ 42 })
+    private val tl2 = ThreadLocal.withInitial({ 239 })
+
+    private val unconfined = Dispatchers.Unconfined
+    private val unconfinedOneElement = Dispatchers.Unconfined + tl.asContextElement()
+    private val unconfinedTwoElements = Dispatchers.Unconfined + tl.asContextElement() + tl2.asContextElement()
 
     @Benchmark
     fun channelPipeline(): Int = runBlocking {
-        Channel
-            .range(1, 1_000_000, Unconfined)
-            .filter(Unconfined) { it % 4 == 0 }
+        run(unconfined)
+    }
+
+    @Benchmark
+    fun channelPipelineOneThreadLocal(): Int = runBlocking {
+        run(unconfinedOneElement)
+    }
+
+    @Benchmark
+    fun channelPipelineTwoThreadLocals(): Int = runBlocking {
+        run(unconfinedTwoElements)
+    }
+
+    private suspend inline fun run(context: CoroutineContext): Int {
+        return Channel
+            .range(1, 1_000_000, context)
+            .filter(context) { it % 4 == 0 }
             .fold(0) { a, b -> a + b }
     }
 
-    private fun Channel.Factory.range(start: Int, count: Int, context: CoroutineContext) = produce(context) {
+    private fun Channel.Factory.range(start: Int, count: Int, context: CoroutineContext) = GlobalScope.produce(context) {
         for (i in start until (start + count))
             send(i)
     }

benchmarks/src/jmh/kotlin/benchmarks/ForkJoinBenchmark.kt

@@ -4,7 +4,7 @@
 
 package benchmarks
 
-import kotlinx.coroutines.experimental.*
+import kotlinx.coroutines.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
 
@@ -54,7 +54,7 @@ open class ForkJoinBenchmark : ParametrizedDispatcherBase() {
 
     @Benchmark
     fun asyncFjp() = runBlocking {
-        CoroutineScope(CommonPool).startAsync(coefficients, 0, coefficients.size).await()
+        CoroutineScope(ForkJoinPool.commonPool().asCoroutineDispatcher()).startAsync(coefficients, 0, coefficients.size).await()
     }
 
     @Benchmark

benchmarks/src/jmh/kotlin/benchmarks/LaunchBenchmark.kt

@@ -4,7 +4,7 @@
 
 package benchmarks
 
-import kotlinx.coroutines.experimental.*
+import kotlinx.coroutines.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
 

benchmarks/src/jmh/kotlin/benchmarks/ParametrizedDispatcherBase.kt

@@ -5,13 +5,14 @@
 package benchmarks
 
 import benchmarks.actors.CORES_COUNT
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.scheduling.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.scheduling.*
 import org.openjdk.jmh.annotations.Param
 import org.openjdk.jmh.annotations.Setup
 import org.openjdk.jmh.annotations.TearDown
 import java.io.Closeable
-import kotlin.coroutines.experimental.CoroutineContext
+import java.util.concurrent.*
+import kotlin.coroutines.CoroutineContext
 
 /**
  * Base class to use different [CoroutineContext] in benchmarks via [Param] in inheritors.
@@ -23,10 +24,11 @@ abstract class ParametrizedDispatcherBase : CoroutineScope {
     override lateinit var coroutineContext: CoroutineContext
     var closeable: Closeable? = null
 
+    @UseExperimental(InternalCoroutinesApi::class)
     @Setup
     open fun setup() {
         coroutineContext = when {
-            dispatcher == "fjp" -> CommonPool
+            dispatcher == "fjp" -> ForkJoinPool.commonPool().asCoroutineDispatcher()
             dispatcher == "experimental" -> {
                 ExperimentalCoroutineDispatcher(CORES_COUNT).also { closeable = it }
             }

benchmarks/src/jmh/kotlin/benchmarks/StatefulAwaitsBenchmark.kt

@@ -4,8 +4,8 @@
 
 package benchmarks
 
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.channels.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
 

benchmarks/src/jmh/kotlin/benchmarks/actors/ConcurrentStatefulActorBenchmark.kt

@@ -6,8 +6,8 @@ package benchmarks.actors
 
 import benchmarks.*
 import benchmarks.actors.StatefulActorBenchmark.*
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.channels.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*
 

benchmarks/src/jmh/kotlin/benchmarks/actors/CycledActorsBenchmark.kt

@@ -6,8 +6,8 @@ package benchmarks.actors
 
 import benchmarks.*
 import benchmarks.actors.PingPongActorBenchmark.*
-import kotlinx.coroutines.experimental.*
-import kotlinx.coroutines.experimental.channels.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.openjdk.jmh.annotations.*
 import java.util.concurrent.*