Rename CoroutineContext.context to coroutineContext

Author: elizarov

benchmarks/src/main/kotlin/benchmarks/PingPongActorBenchmark.kt

@@ -128,8 +128,8 @@ open class PingPongActorBenchmark {
 
     @Benchmark
     fun pingPongCoroutineMain() = runBlocking<Unit> {
-        val pong = pongActorCoroutine(context)
-        val ping = pingActorCoroutine(context, pong)
+        val pong = pongActorCoroutine(coroutineContext)
+        val ping = pingActorCoroutine(coroutineContext, pong)
         val me = Channel<Letter>()
         ping.send(Letter(Start(), me))
         me.receive()

coroutines-guide.md

@@ -749,16 +749,16 @@ to a specific thread, dispatch it to a thread pool, or let it run unconfined. Tr
 fun main(args: Array<String>) = runBlocking<Unit> {
     val jobs = arrayListOf<Job>()
     jobs += launch(Unconfined) { // not confined -- will work with main thread
-        println(" 'Unconfined': I'm working in thread ${Thread.currentThread().name}")
+        println("      'Unconfined': I'm working in thread ${Thread.currentThread().name}")
     }
-    jobs += launch(context) { // context of the parent, runBlocking coroutine
-        println("    'context': I'm working in thread ${Thread.currentThread().name}")
+    jobs += launch(coroutineContext) { // context of the parent, runBlocking coroutine
+        println("'coroutineContext': I'm working in thread ${Thread.currentThread().name}")
     }
     jobs += launch(CommonPool) { // will get dispatched to ForkJoinPool.commonPool (or equivalent)
-        println(" 'CommonPool': I'm working in thread ${Thread.currentThread().name}")
+        println("      'CommonPool': I'm working in thread ${Thread.currentThread().name}")
     }
     jobs += launch(newSingleThreadContext("MyOwnThread")) { // will get its own new thread
-        println("     'newSTC': I'm working in thread ${Thread.currentThread().name}")
+        println("          'newSTC': I'm working in thread ${Thread.currentThread().name}")
     }
     jobs.forEach { it.join() }
 }
@@ -769,15 +769,16 @@ fun main(args: Array<String>) = runBlocking<Unit> {
 It produces the following output (maybe in different order):
 
 ```text
- 'Unconfined': I'm working in thread main
- 'CommonPool': I'm working in thread ForkJoinPool.commonPool-worker-1
-     'newSTC': I'm working in thread MyOwnThread
-    'context': I'm working in thread main
+      'Unconfined': I'm working in thread main
+      'CommonPool': I'm working in thread ForkJoinPool.commonPool-worker-1
+          'newSTC': I'm working in thread MyOwnThread
+'coroutineContext': I'm working in thread main
 ```
 
 <!--- TEST LINES_START_UNORDERED -->
 
-The difference between parent [context][CoroutineScope.context] and [Unconfined] context will be shown later.
+The difference between parent [coroutineContext][CoroutineScope.coroutineContext] and
+[Unconfined] context will be shown later.
 
 ### Unconfined vs confined dispatcher
 
@@ -786,7 +787,7 @@ first suspension point. After suspension it resumes in the thread that is fully
 suspending function that was invoked. Unconfined dispatcher is appropriate when coroutine does not
 consume CPU time nor updates any shared data (like UI) that is confined to a specific thread. 
 
-On the other side, [context][CoroutineScope.context] property that is available inside the block of any coroutine 
+On the other side, [coroutineContext][CoroutineScope.coroutineContext] property that is available inside the block of any coroutine
 via [CoroutineScope] interface, is a reference to a context of this particular coroutine. 
 This way, a parent context can be inherited. The default context of [runBlocking], in particular,
 is confined to be invoker thread, so inheriting it has the effect of confining execution to
@@ -796,14 +797,14 @@ this thread with a predictable FIFO scheduling.
 fun main(args: Array<String>) = runBlocking<Unit> {
     val jobs = arrayListOf<Job>()
     jobs += launch(Unconfined) { // not confined -- will work with main thread
-        println(" 'Unconfined': I'm working in thread ${Thread.currentThread().name}")
+        println("      'Unconfined': I'm working in thread ${Thread.currentThread().name}")
         delay(500)
-        println(" 'Unconfined': After delay in thread ${Thread.currentThread().name}")
+        println("      'Unconfined': After delay in thread ${Thread.currentThread().name}")
     }
-    jobs += launch(context) { // context of the parent, runBlocking coroutine
-        println("    'context': I'm working in thread ${Thread.currentThread().name}")
+    jobs += launch(coroutineContext) { // context of the parent, runBlocking coroutine
+        println("'coroutineContext': I'm working in thread ${Thread.currentThread().name}")
         delay(1000)
-        println("    'context': After delay in thread ${Thread.currentThread().name}")
+        println("'coroutineContext': After delay in thread ${Thread.currentThread().name}")
     }
     jobs.forEach { it.join() }
 }
@@ -814,16 +815,17 @@ fun main(args: Array<String>) = runBlocking<Unit> {
 Produces the output: 
 
 ```text
- 'Unconfined': I'm working in thread main
-    'context': I'm working in thread main
- 'Unconfined': After delay in thread kotlinx.coroutines.DefaultExecutor
-    'context': After delay in thread main
+      'Unconfined': I'm working in thread main
+'coroutineContext': I'm working in thread main
+      'Unconfined': After delay in thread kotlinx.coroutines.DefaultExecutor
+'coroutineContext': After delay in thread main
 ```
 
 <!--- TEST LINES_START -->
 
-So, the coroutine that had inherited `context` of `runBlocking {...}` continues to execute in the `main` thread,
-while the unconfined one had resumed in the default executor thread that [delay] function is using.
+So, the coroutine that had inherited `coroutineContext` of `runBlocking {...}` continues to execute
+in the `main` thread, while the unconfined one had resumed in the default executor thread that [delay]
+function is using.
 
 ### Debugging coroutines and threads
 
@@ -840,11 +842,11 @@ Run the following code with `-Dkotlinx.coroutines.debug` JVM option:
 fun log(msg: String) = println("[${Thread.currentThread().name}] $msg")
 
 fun main(args: Array<String>) = runBlocking<Unit> {
-    val a = async(context) {
+    val a = async(coroutineContext) {
         log("I'm computing a piece of the answer")
         6
     }
-    val b = async(context) {
+    val b = async(coroutineContext) {
         log("I'm computing another piece of the answer")
         7
     }
@@ -910,11 +912,11 @@ same coroutine as you can see in the output below:
 ### Job in the context
 
 The coroutine [Job] is part of its context. The coroutine can retrieve it from its own context 
-using `context[Job]` expression:
+using `coroutineContext[Job]` expression:
 
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
-    println("My job is ${context[Job]}")
+    println("My job is ${coroutineContext[Job]}")
 }
 ```
 
@@ -928,11 +930,12 @@ My job is BlockingCoroutine{Active}@65ae6ba4
 
 <!--- TEST lines.size == 1 && lines[0].startsWith("My job is BlockingCoroutine{Active}@") -->
 
-So, [isActive][CoroutineScope.isActive] in [CoroutineScope] is just a convenient shortcut for `context[Job]!!.isActive`.
+So, [isActive][CoroutineScope.isActive] in [CoroutineScope] is just a convenient shortcut for
+`coroutineContext[Job]!!.isActive`.
 
 ### Children of a coroutine
 
-When [context][CoroutineScope.context] of a coroutine is used to launch another coroutine, 
+When [coroutineContext][CoroutineScope.coroutineContext] of a coroutine is used to launch another coroutine,
 the [Job] of the new coroutine becomes
 a _child_ of the parent coroutine's job. When the parent coroutine is cancelled, all its children
 are recursively cancelled, too. 
@@ -948,7 +951,7 @@ fun main(args: Array<String>) = runBlocking<Unit> {
             println("job1: I am not affected by cancellation of the request")
         }
         // and the other inherits the parent context
-        val job2 = launch(context) {
+        val job2 = launch(coroutineContext) {
             println("job2: I am a child of the request coroutine")
             delay(1000)
             println("job2: I will not execute this line if my parent request is cancelled")
@@ -986,9 +989,9 @@ its dispatcher replaced:
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     // start a coroutine to process some kind of incoming request
-    val request = launch(context) { // use the context of `runBlocking`
+    val request = launch(coroutineContext) { // use the context of `runBlocking`
         // spawns CPU-intensive child job in CommonPool !!! 
-        val job = launch(context + CommonPool) {
+        val job = launch(coroutineContext + CommonPool) {
             println("job: I am a child of the request coroutine, but with a different dispatcher")
             delay(1000)
             println("job: I will not execute this line if my parent request is cancelled")
@@ -1075,7 +1078,7 @@ fun main(args: Array<String>) = runBlocking<Unit> {
     // now launch ten coroutines for a demo, each working for a different time
     val coroutines = List(10) { i ->
         // they are all children of our job object
-        launch(context + job) { // we use the context of main runBlocking thread, but with our own job object 
+        launch(coroutineContext + job) { // we use the context of main runBlocking thread, but with our own job object
             delay(i * 200L) // variable delay 0ms, 200ms, 400ms, ... etc
             println("Coroutine $i is done")
         }
@@ -1305,11 +1308,11 @@ running the whole pipeline in the context of the main thread:
 
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
-    var cur = numbersFrom(context, 2)
+    var cur = numbersFrom(coroutineContext, 2)
     for (i in 1..10) {
         val prime = cur.receive()
         println(prime)
-        cur = filter(context, cur, prime)
+        cur = filter(coroutineContext, cur, prime)
     }
 }
 ```
@@ -1426,8 +1429,8 @@ Now, let us see what happens if we launch a couple of coroutines sending strings
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     val channel = Channel<String>()
-    launch(context) { sendString(channel, "foo", 200L) }
-    launch(context) { sendString(channel, "BAR!", 500L) }
+    launch(coroutineContext) { sendString(channel, "foo", 200L) }
+    launch(coroutineContext) { sendString(channel, "BAR!", 500L) }
     repeat(6) { // receive first six
         println(channel.receive())
     }
@@ -1464,7 +1467,7 @@ Take a look at the behavior of the following code:
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     val channel = Channel<Int>(4) // create buffered channel
-    launch(context) { // launch sender coroutine
+    launch(coroutineContext) { // launch sender coroutine
         repeat(10) {
             println("Sending $it") // print before sending each element
             channel.send(it) // will suspend when buffer is full
@@ -1504,8 +1507,8 @@ data class Ball(var hits: Int)
 
 fun main(args: Array<String>) = runBlocking<Unit> {
     val table = Channel<Ball>() // a shared table
-    launch(context) { player("ping", table) }
-    launch(context) { player("pong", table) }
+    launch(coroutineContext) { player("ping", table) }
+    launch(coroutineContext) { player("pong", table) }
     table.send(Ball(0)) // serve the ball
     delay(1000) // delay 1 second
     table.receive() // game over, grab the ball
@@ -1893,8 +1896,8 @@ Let us run it all seven times:
 
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
-    val fizz = fizz(context)
-    val buzz = buzz(context)
+    val fizz = fizz(coroutineContext)
+    val buzz = buzz(coroutineContext)
     repeat(7) {
         selectFizzBuzz(fizz, buzz)
     }
@@ -1948,10 +1951,10 @@ channel `b` that produces "World" four times:
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     // we are using the context of the main thread in this example for predictability ... 
-    val a = produce<String>(context) { 
+    val a = produce<String>(coroutineContext) {
         repeat(4) { send("Hello $it") }
     }
-    val b = produce<String>(context) { 
+    val b = produce<String>(coroutineContext) {
         repeat(4) { send("World $it") }
     }
     repeat(8) { // print first eight results
@@ -2012,7 +2015,7 @@ Consumer is going to be quite slow, taking 250 ms to process each number:
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     val side = Channel<Int>() // allocate side channel
-    launch(context) { // this is a very fast consumer for the side channel
+    launch(coroutineContext) { // this is a very fast consumer for the side channel
         side.consumeEach { println("Side channel has $it") }
     }
     produceNumbers(side).consumeEach { 
@@ -2145,7 +2148,7 @@ data to it:
 ```kotlin
 fun main(args: Array<String>) = runBlocking<Unit> {
     val chan = Channel<Deferred<String>>() // the channel for test
-    launch(context) { // launch printing coroutine
+    launch(coroutineContext) { // launch printing coroutine
         for (s in switchMapDeferreds(chan)) 
             println(s) // print each received string
     }
@@ -2202,7 +2205,7 @@ Channel was closed
 [Job.start]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-job/start.html
 [CommonPool]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-common-pool/index.html
 [CoroutineDispatcher]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-dispatcher/index.html
-[CoroutineScope.context]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-scope/context.html
+[CoroutineScope.coroutineContext]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-scope/coroutine-context.html
 [Unconfined]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-unconfined/index.html
 [newCoroutineContext]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/new-coroutine-context.html
 [CoroutineName]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-name/index.html

integration/kotlinx-coroutines-guava/src/main/kotlin/kotlinx/coroutines/experimental/guava/ListenableFuture.kt

@@ -64,6 +64,7 @@ public fun <T> future(
 private class ListenableFutureCoroutine<T>(
     override val context: CoroutineContext
 ) : AbstractFuture<T>(), Continuation<T>, CoroutineScope {
+    override val coroutineContext: CoroutineContext get() = context
     override val isActive: Boolean get() = context[Job]!!.isActive
     override fun resume(value: T) { set(value) }
     override fun resumeWithException(exception: Throwable) { setException(exception) }

integration/kotlinx-coroutines-guava/src/test/kotlin/kotlinx/coroutines/experimental/guava/ListenableFutureTest.kt

@@ -119,7 +119,7 @@ class ListenableFutureTest : TestBase() {
     @Test
     fun testCompletedDeferredAsListenableFuture() = runBlocking {
         expect(1)
-        val deferred = async(context, CoroutineStart.UNDISPATCHED) {
+        val deferred = async(coroutineContext, CoroutineStart.UNDISPATCHED) {
             expect(2) // completed right away
             "OK"
         }
@@ -132,7 +132,7 @@ class ListenableFutureTest : TestBase() {
     @Test
     fun testWaitForDeferredAsListenableFuture() = runBlocking {
         expect(1)
-        val deferred = async(context) {
+        val deferred = async(coroutineContext) {
             expect(3) // will complete later
             "OK"
         }
@@ -146,7 +146,7 @@ class ListenableFutureTest : TestBase() {
     fun testCancellableAwait() = runBlocking {
         expect(1)
         val toAwait = SettableFuture.create<String>()
-        val job = launch(context, CoroutineStart.UNDISPATCHED) {
+        val job = launch(coroutineContext, CoroutineStart.UNDISPATCHED) {
             expect(2)
             try {
                 toAwait.await() // suspends

integration/kotlinx-coroutines-jdk8/src/main/kotlin/kotlinx/coroutines/experimental/future/Future.kt

@@ -66,6 +66,7 @@ public fun <T> future(
 private class CompletableFutureCoroutine<T>(
     override val context: CoroutineContext
 ) : CompletableFuture<T>(), Continuation<T>, CoroutineScope {
+    override val coroutineContext: CoroutineContext get() = context
     override val isActive: Boolean get() = context[Job]!!.isActive
     override fun resume(value: T) { complete(value) }
     override fun resumeWithException(exception: Throwable) { completeExceptionally(exception) }

integration/kotlinx-coroutines-jdk8/src/test/kotlin/kotlinx/coroutines/experimental/future/FutureTest.kt

@@ -168,7 +168,7 @@ class FutureTest : TestBase() {
     @Test
     fun testCompletedDeferredAsCompletableFuture() = runBlocking {
         expect(1)
-        val deferred = async(context, CoroutineStart.UNDISPATCHED) {
+        val deferred = async(coroutineContext, CoroutineStart.UNDISPATCHED) {
             expect(2) // completed right away
             "OK"
         }
@@ -181,7 +181,7 @@ class FutureTest : TestBase() {
     @Test
     fun testWaitForDeferredAsCompletableFuture() = runBlocking {
         expect(1)
-        val deferred = async(context) {
+        val deferred = async(coroutineContext) {
             expect(3) // will complete later
             "OK"
         }
@@ -195,7 +195,7 @@ class FutureTest : TestBase() {
     fun testCancellableAwaitFuture() = runBlocking {
         expect(1)
         val toAwait = CompletableFuture<String>()
-        val job = launch(context, CoroutineStart.UNDISPATCHED) {
+        val job = launch(coroutineContext, CoroutineStart.UNDISPATCHED) {
             expect(2)
             try {
                 toAwait.await() // suspends
@@ -217,7 +217,7 @@ class FutureTest : TestBase() {
         expect(1)
         val completable = CompletableFuture<String>()
         val toAwait: CompletionStage<String> = completable
-        val job = launch(context, CoroutineStart.UNDISPATCHED) {
+        val job = launch(coroutineContext, CoroutineStart.UNDISPATCHED) {
             expect(2)
             assertThat(toAwait.await(), IsEqual("OK")) // suspends
             expect(5)

integration/kotlinx-coroutines-nio/src/test/kotlin/examples/echo-example.kt

@@ -50,7 +50,7 @@ fun main(args: Array<String>) = runBlocking {
         }
         log("Accepted client connection from $address")
         // just start a new coroutine for each client connection
-        launch(context) {
+        launch(coroutineContext) {
             try {
                 handleClient(client)
                 log("Client connection from $address has terminated normally")

integration/kotlinx-coroutines-nio/src/test/kotlin/kotlinx/coroutines/experimental/nio/AsyncIOTest.kt

@@ -83,7 +83,7 @@ class AsyncIOTest {
 
         val serverPort = (serverChannel.localAddress as InetSocketAddress).port
 
-        val c1 = launch(context) {
+        val c1 = launch(coroutineContext) {
             val client = serverChannel.aAccept()
             val buffer = ByteBuffer.allocate(2)
             client.aRead(buffer)
@@ -94,7 +94,7 @@ class AsyncIOTest {
             client.close()
         }
 
-        val c2 = launch(context) {
+        val c2 = launch(coroutineContext) {
             val connection =
                     AsynchronousSocketChannel.open()
             // async calls

kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/AbstractCoroutine.kt

@@ -33,6 +33,7 @@ public abstract class AbstractCoroutine<in T>(
 ) : JobSupport(active), Continuation<T>, CoroutineScope {
     @Suppress("LeakingThis")
     public final override val context: CoroutineContext = parentContext + this
+    public final override val coroutineContext: CoroutineContext get() = context
 
     final override val hasCancellingState: Boolean get() = true