Kotlin/Native support

* Using Gradle 4.7
* Using Kotlin/Native 0.9-dev-2922

Fixes #246

Author: qwwdfsad

build.gradle

@@ -101,10 +101,13 @@ def internal = sourceless + ['benchmarks', 'knit', 'js-stub', 'binary-compatibil
 
 // Reconfigure source sets to avoid long "src/main/kotlin/fqn"
 configure(subprojects.findAll { !it.name.contains(sourceless) && it.name != "benchmarks" }) {
+    def projectName = it.name
     sourceSets {
         main.kotlin.srcDirs = ['src']
         test.kotlin.srcDirs = ['test']
-        main.resources.srcDirs = ['resources']
+        if (!projectName.endsWith("-native")) {
+            main.resources.srcDirs = ['resources']
+        }
     }
 }
 
@@ -135,7 +138,7 @@ configure(subprojects.findAll { !internal.contains(it.name) && it.name != 'kotli
 // --------------- Configure sub-projects that are published ---------------
 
 // todo: native is not published yet
-def unpublished = internal + ['kotlinx-coroutines-rx-example', 'example-frontend-js', 'kotlinx-coroutines-core-native']
+def unpublished = internal + ['kotlinx-coroutines-rx-example', 'example-frontend-js']
 
 def core_docs_url = "https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/"
 def core_docs_file = "$projectDir/core/kotlinx-coroutines-core/build/dokka/kotlinx-coroutines-core/package-list"

common/kotlinx-coroutines-core-common/src/channels/ConflatedChannel.kt

@@ -4,8 +4,7 @@
 
 package kotlinx.coroutines.experimental.channels
 
-import kotlinx.coroutines.experimental.selects.ALREADY_SELECTED
-import kotlinx.coroutines.experimental.selects.SelectInstance
+import kotlinx.coroutines.experimental.selects.*
 
 /**
  * Channel that buffers at most one element and conflates all subsequent `send` and `offer` invocations,
@@ -43,6 +42,7 @@ public open class ConflatedChannel<E> : AbstractChannel<E>() {
                     when (sendResult) {
                         null -> return OFFER_SUCCESS
                         is Closed<*> -> return sendResult
+                        else -> Unit // todo:KLUDGE: works around native BE bug
                     }
                     // otherwise there was receiver in queue, retry super.offerInternal
                 }

common/kotlinx-coroutines-core-common/src/channels/LinkedListChannel.kt

@@ -4,8 +4,7 @@
 
 package kotlinx.coroutines.experimental.channels
 
-import kotlinx.coroutines.experimental.selects.ALREADY_SELECTED
-import kotlinx.coroutines.experimental.selects.SelectInstance
+import kotlinx.coroutines.experimental.selects.*
 
 /**
  * Channel with linked-list buffer of a unlimited capacity (limited only by available memory).
@@ -32,6 +31,7 @@ public open class LinkedListChannel<E> : AbstractChannel<E>() {
                     when (sendResult) {
                         null -> return OFFER_SUCCESS
                         is Closed<*> -> return sendResult
+                        else -> Unit // todo:KLUDGE: works around native BE bug
                     }
                     // otherwise there was receiver in queue, retry super.offerInternal
                 }

common/kotlinx-coroutines-core-common/test/channels/ChannelsTest.kt

@@ -5,6 +5,7 @@
 package kotlinx.coroutines.experimental.channels
 
 import kotlinx.coroutines.experimental.*
+import kotlin.coroutines.experimental.*
 import kotlin.math.*
 import kotlin.test.*
 
@@ -132,7 +133,7 @@ class ChannelsTest: TestBase() {
 
     @Test
     fun testMapToSendChannel() = runTest {
-        val c = produce<Int> {
+        val c = produce<Int>(coroutineContext) {
             testList.asReceiveChannel().mapTo(channel) { it + 10 }
         }
         assertEquals(testList.map { it + 10 }, c.toList())
@@ -327,7 +328,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testFilterToSendChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().filterTo(channel) { it % 2 == mod }
             }
             assertEquals(testList.filter { it % 2 == mod }, c.toList())
@@ -354,7 +355,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testFilterNotToSendChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().filterNotTo(channel) { it % 2 == mod }
             }
             assertEquals(testList.filterNot { it % 2 == mod }, c.toList())
@@ -381,7 +382,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testFilterNotNullToSendChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().map { it.takeIf { it % 2 == mod } }.filterNotNullTo(channel)
             }
             assertEquals(testList.map { it.takeIf { it % 2 == mod } }.filterNotNull(), c.toList())
@@ -408,7 +409,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testFilterIndexedToChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().filterIndexedTo(channel) { index, _ -> index % 2 == mod }
             }
             assertEquals(testList.filterIndexed { index, _ ->  index % 2 == mod }, c.toList())
@@ -425,7 +426,7 @@ class ChannelsTest: TestBase() {
 
     @Test
     fun testToChannel() = runTest {
-        val c = produce<Int> {
+        val c = produce<Int>(coroutineContext) {
             testList.asReceiveChannel().toChannel(channel)
         }
         assertEquals(testList, c.toList())
@@ -446,7 +447,7 @@ class ChannelsTest: TestBase() {
 
     @Test
     fun testMapIndexedToSendChannel() = runTest {
-        val c = produce<Int> {
+        val c = produce<Int>(coroutineContext) {
             testList.asReceiveChannel().mapIndexedTo(channel) { index, i -> index + i }
         }
         assertEquals(testList.mapIndexed { index, i -> index + i }, c.toList())
@@ -472,7 +473,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testMapNotNullToSendChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().mapNotNullTo(channel) { i -> i.takeIf { i % 2 == mod } }
             }
             assertEquals(testList.mapNotNull { i -> i.takeIf { i % 2 == mod } }, c.toList())
@@ -499,7 +500,7 @@ class ChannelsTest: TestBase() {
     @Test
     fun testMapIndexedNotNullToSendChannel() = runTest {
         repeat(3) { mod ->
-            val c = produce<Int> {
+            val c = produce<Int>(coroutineContext) {
                 testList.asReceiveChannel().mapIndexedNotNullTo(channel) { index, i -> index.takeIf { i % 2 == mod } }
             }
             assertEquals(testList.mapIndexedNotNull { index, i -> index.takeIf { i % 2 == mod } }, c.toList())

common/kotlinx-coroutines-core-common/test/sync/MutexTest.kt

@@ -5,8 +5,8 @@
 package kotlinx.coroutines.experimental.sync
 
 import kotlinx.coroutines.experimental.*
-import kotlin.test.*
 import kotlin.coroutines.experimental.*
+import kotlin.test.*
 
 class MutexTest : TestBase() {
     @Test
@@ -87,7 +87,7 @@ class MutexTest : TestBase() {
 
         // owner firstOwner
         mutex.lock(firstOwner)
-        val secondLockJob = launch {
+        val secondLockJob = launch(coroutineContext) {
             mutex.lock(secondOwner)
         }
 

core/kotlinx-coroutines-core/src/internal/ArrayCopy.kt

@@ -4,6 +4,12 @@
 
 package kotlinx.coroutines.experimental.internal
 
-internal actual fun <E> arraycopy(source: Array<E>, srcPos: Int, destination: Array<E?>, destinationStart: Int, length: Int){
+internal actual fun <E> arraycopy(
+    source: Array<E>,
+    srcPos: Int,
+    destination: Array<E?>,
+    destinationStart: Int,
+    length: Int
+) {
     System.arraycopy(source, srcPos, destination, destinationStart, length)
 }

core/kotlinx-coroutines-core/src/internal/Concurrent.kt

@@ -7,7 +7,7 @@ package kotlinx.coroutines.experimental.internal
 import java.util.concurrent.*
 import kotlin.concurrent.withLock as withLockJvm
 
-internal actual fun <E> subscriberList(): MutableList<E> = CopyOnWriteArrayList<E>()
+internal actual fun <E> subscriberList(): SubscribersList<E> = CopyOnWriteArrayList<E>()
 
 @Suppress("ACTUAL_WITHOUT_EXPECT")
 internal actual typealias ReentrantLock = java.util.concurrent.locks.ReentrantLock

gradle.properties

@@ -6,13 +6,13 @@ version = 0.23.4-SNAPSHOT
 group = org.jetbrains.kotlinx
 
 kotlin_version = 1.2.51
-kotlin_native_version = 0.7-dev-1436
+kotlin_native_version = 0.9-dev-2922
 junit_version = 4.12
-atomicFU_version = 0.10.3
+atomicFU_version = 0.11.0
 html_version = 0.6.8
 lincheck_version=1.9
 dokka_version = 0.9.16-rdev-2-mpp-hacks
-bintray_version = 1.7.3
+bintray_version = 1.8.2-SNAPSHOT
 
 gradle_node_version = 1.2.0
 node_version = 8.9.3

gradle/atomicfu-native.gradle

@@ -2,8 +2,6 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-// todo: this does not work in Kotlin/Native
-
-//dependencies {
-//    compile "org.jetbrains.kotlinx:atomicfu-native:$atomicFU_version"
-//}
+dependencies {
+    implementation "org.jetbrains.kotlinx:atomicfu-native:$atomicFU_version"
+}

gradle/compile-native.gradle

@@ -2,35 +2,30 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-apply plugin: 'konan'
+apply plugin: "kotlin-platform-native"
 
-def libraryName = project.name
-def testProgramName = libraryName + "-test"
+apply from: project.rootProject.file('gradle/maven-central.gradle')
 
-konanArtifacts {
-    library(libraryName, targets: ["ios_arm64", "ios_x64", "macos_x64"]) {
-        artifactName libraryName.replace('-', '_')
-        enableMultiplatform true
-        dependencies {
-            "artifact$libraryName" "org.jetbrains.kotlinx:atomicfu-native:$atomicFU_version"
-        }
-    }
-    // TODO: THIS IS A WORKAROUND: Cannot do tests together with publishing in Kotlin/Native
-    if (!rootProject.properties["publish"]) {
-        program(testProgramName, targets: ["macos_x64"]) {
-            srcDir 'src/test/kotlin'
-            commonSourceSet 'test'
-            libraries {
-                artifact libraryName
+sourceSets {
+    main {
+        component {
+            target "ios_arm64", "ios_arm32", "ios_x64", "macos_x64", "linux_x64", "mingw_x64"
+            outputKinds = [KLIBRARY]
+            pom {
+                withXml(configureMavenCentralMetadata)
             }
-            extraOpts '-tr'
         }
     }
 }
 
-task test(dependsOn: run)
-
-// TODO: THIS IS A WORKAROUND: Cannot do tests together with publishing in Kotlin/Native
-if (rootProject.properties["publish"]) {
-    publishToMavenLocal.dependsOn(build)
+dependencies {
+    expectedBy project(':kotlinx-coroutines-core-common')
 }
+
+if (project.hasProperty("teamcity")) {
+    afterEvaluate {
+        runTestDebug {
+            args '--ktest_logger=TEAMCITY'
+        }
+    }
+}