Support generation of VarHandle variant

Author: elizarov

README.md

@@ -124,6 +124,8 @@ which is then transformed to a regular `classes` directory to be used later by t
                         </goals>
                         <configuration>
                             <output>${project.build.directory}/classes-pre-atomicfu</output>
+                            <!-- "VH" to use Java 9 VarHandle, "BOTH" to produce multi-version code -->
+                            <variant>FU</variant>  
                         </configuration>
                     </execution>
                 </executions>
@@ -150,7 +152,8 @@ which is then transformed to a regular `classes` directory to be used later by t
 
 ## Gradle build setup
 
-Add and apply AtmoicFU plugin:
+You will need Gradle 4.0 or later for the following snippets to work.
+Add and apply AtomicFU plugin:
 
 ```groovy
 buildscript {
@@ -182,6 +185,7 @@ atomicFU {
     inputFiles = sourceSets.main.output.classesDirs
     outputDir = CLASSES_POST_ATOMICFU
     classPath = sourceSets.main.runtimeClasspath
+    variant = "FU" // "VH" to use Java 9 VarHandle, "BOTH" to produce multi-version code
 }
 
 atomicFU.dependsOn compileKotlin
@@ -193,6 +197,17 @@ jar {
 }
 ```
 
+## VarHandles with Java 9 (optional)
+
+AtomicFU can produce code that is using Java 9 
+[VarHandle](http://download.java.net/java/jdk9/docs/api/java/lang/invoke/VarHandle.html)
+instead of `AtomicXXXFieldUpdater`. Set `variant` configuration option to `VH`.  
+
+You can also create [JEP 238](http://openjdk.java.net/jeps/238) multi-release jar with both
+`AtomicXXXFieldUpdater` baseline and `VarHandle` version for Java 9+. 
+Set `variant` configuration option to `BOTH` and configure `Multi-Release: true` attribute
+in the resulting jar manifest.
+
 ## Testing lock-free data structures (optional)
 
 You can optionally test lock-freedomness of lock-free data structures using `LockFreedomTestEnvironment` class.

atomicfu-gradle-plugin/src/main/kotlin/kotlinx/atomicfu/plugin/gradle/AtomicFUGradlePlugin.kt

@@ -1,6 +1,7 @@
 package kotlinx.atomicfu.plugin.gradle
 
 import kotlinx.atomicfu.transformer.AtomicFUTransformer
+import kotlinx.atomicfu.transformer.Variant
 import org.gradle.api.DefaultTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -27,12 +28,15 @@ open class AtomicFUTransformTask : DefaultTask() {
     @InputFiles
     var classPath: FileCollection = project.files()
     @Input
-    var verbose: Boolean = false
+    var verbose = false
+    @Input
+    var variant= Variant.FU
 
     @TaskAction
     fun transform() {
         inputFiles.files.forEach {
-            val t = AtomicFUTransformer(classPath.files.map { it.absolutePath }, it, outputDir)
+            val t = AtomicFUTransformer(
+                classPath.files.map { it.absolutePath }, it, outputDir, variant)
             t.verbose = verbose
             t.transform()
         }

atomicfu-maven-plugin/src/main/kotlin/kotlinx/atomicfu/plugin/TransformMojo.kt

@@ -17,6 +17,7 @@
 package kotlinx.atomicfu.plugin
 
 import kotlinx.atomicfu.transformer.AtomicFUTransformer
+import kotlinx.atomicfu.transformer.Variant
 import org.apache.maven.plugin.AbstractMojo
 import org.apache.maven.plugins.annotations.LifecyclePhase
 import org.apache.maven.plugins.annotations.Mojo
@@ -46,14 +47,20 @@ class TransformMojo : AbstractMojo() {
     @Parameter(defaultValue = "\${project.build.outputDirectory}", property = "output", required = true)
     lateinit var output: File
 
+    /**
+     * Transformation variant: "FU", "VH", or "BOTH".
+     */
+    @Parameter(defaultValue = "FU", property = "variant", required = true)
+    lateinit var variant: Variant
+
     /**
      * Verbose debug info.
      */
     @Parameter(defaultValue = "false", property = "verbose", required = false)
     var verbose: Boolean = false
 
     override fun execute() {
-        val t = AtomicFUTransformer(classpath, input, output)
+        val t = AtomicFUTransformer(classpath, input, output, variant)
         t.verbose = verbose
         t.transform()
     }

atomicfu-test/src/main/kotlin/kotlinx/atomicfu/test/IntArithmetic.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.atomicfu.test
+
+import kotlinx.atomicfu.atomic
+
+class IntArithmetic {
+    private val _x = atomic(0)
+    val x get() = _x.value
+
+    fun lazySet(v: Int) = _x.lazySet(v)
+    fun getAndSet(v: Int) = _x.getAndSet(v)
+    fun getAndIncrement() = _x.getAndIncrement()
+    fun getAndDecrement() = _x.getAndDecrement()
+    fun getAndAdd(v: Int) = _x.getAndAdd(v)
+    fun addAndGet(v: Int) = _x.addAndGet(v)
+    fun incrementAndGet() = _x.incrementAndGet()
+    fun decrementAndGet() = _x.decrementAndGet()
+}

atomicfu-test/src/main/kotlin/kotlinx/atomicfu/test/LongArithmetic.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.atomicfu.test
+
+import kotlinx.atomicfu.atomic
+
+class LongArithmetic {
+    private val _x = atomic(0L)
+    val x get() = _x.value
+
+    fun lazySet(v: Long) = _x.lazySet(v)
+    fun getAndSet(v: Long) = _x.getAndSet(v)
+    fun getAndIncrement() = _x.getAndIncrement()
+    fun getAndDecrement() = _x.getAndDecrement()
+    fun getAndAdd(v: Long) = _x.getAndAdd(v)
+    fun addAndGet(v: Long) = _x.addAndGet(v)
+    fun incrementAndGet() = _x.incrementAndGet()
+    fun decrementAndGet() = _x.decrementAndGet()
+}

atomicfu-test/src/test/kotlin/kotlinx/atomicfu/test/ArithmeticTest.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.atomicfu.test
+
+import org.junit.Test
+
+class ArithmeticTest {
+    @Test
+    fun testInt() {
+        val a = IntArithmetic()
+        check(a.x == 0)
+        a.lazySet(1)
+        check(a.x == 1)
+        check(a.getAndSet(2) == 1)
+        check(a.x == 2)
+        check(a.getAndIncrement() == 2)
+        check(a.x == 3)
+        check(a.getAndDecrement() == 3)
+        check(a.x == 2)
+        check(a.getAndAdd(2) == 2)
+        check(a.x == 4)
+        check(a.addAndGet(3) == 7)
+        check(a.x == 7)
+        check(a.incrementAndGet() == 8)
+        check(a.x == 8)
+        check(a.decrementAndGet() == 7)
+        check(a.x == 7)
+    }
+
+    @Test
+    fun testLong() {
+        val a = LongArithmetic()
+        check(a.x == 0L)
+        a.lazySet(1)
+        check(a.x == 1L)
+        check(a.getAndSet(2) == 1L)
+        check(a.x == 2L)
+        check(a.getAndIncrement() == 2L)
+        check(a.x == 3L)
+        check(a.getAndDecrement() == 3L)
+        check(a.x == 2L)
+        check(a.getAndAdd(2) == 2L)
+        check(a.x == 4L)
+        check(a.addAndGet(3) == 7L)
+        check(a.x == 7L)
+        check(a.incrementAndGet() == 8L)
+        check(a.x == 8L)
+        check(a.decrementAndGet() == 7L)
+        check(a.x == 7L)
+    }
+}