release: v0.0.2

Author: ForteScarlet

README.md

@@ -58,23 +58,25 @@ class Foo {
         return "Hello"
     }
     @Api4Js // RequiresOptIn annotation, provide warnings to Kotlin
-    fun waitAndGetBlocking(): Promise<String> = runInAsync { waitAndGet() } // 'runInBlocking' from the runtime provided by the plugin
+    fun waitAndGetBlocking(): Promise<String> = runInAsync { waitAndGet() } // 'runInAsync' from the runtime provided by the plugin
 }
 ```
 
 > JS platform target not supported yet. see: [KT-53993](https://youtrack.jetbrains.com/issue/KT-53993)
 
-
 ## Usage
 ### Gradle
 
-**Way 1:**
+**Using the [plugins DSL](https://docs.gradle.org/current/userguide/plugins.html#sec:plugins_block):**
+
+<details open>
+<summary>Kotlin</summary>
 
 _build.gradle.kts_
 
 ```kotlin
-plugins { 
-    kotlin("jvm") // or..?
+plugins {
+    id("org.jetbrains.kotlin.jvm") version "KOTLIN_VERSION" // or js? or multiplatform?
     id("love.forte.plugin.suspend-transform") version "$PLUGIN_VERSION" 
     // other...
 }
@@ -94,7 +96,43 @@ suspendTransform {
 }
 ```
 
-**Way 2:**
+</details>
+
+<details>
+<summary>Groovy</summary>
+
+_build.gradle_
+
+```groovy
+plugins {
+    id "org.jetbrains.kotlin.jvm" // or js? or multiplatform?
+    id "love.forte.plugin.suspend-transform" version "$PLUGIN_VERSION" 
+    // other...
+}
+
+// other...
+
+// config it.
+suspendTransform {
+    enabled = true // default: true
+    includeRuntime = true // default: true
+    jvm {
+        // ...
+    }
+    js {
+        // ...
+    }
+}
+```
+
+</details>
+
+
+
+**Using [legacy plugin application](https://docs.gradle.org/current/userguide/plugins.html#sec:old_plugin_application):**
+
+<details open>
+<summary>Kotlin</summary>
 
 _build.gradle.kts_
 
@@ -109,8 +147,8 @@ buildscript {
     }
 }
 
-plugins { 
-    kotlin("jvm") // or..?
+plugins {
+    id("org.jetbrains.kotlin.jvm") // or js? or multiplatform?
     id("love.forte.plugin.suspend-transform") 
     // other...
 }
@@ -130,10 +168,63 @@ suspendTransform {
 }
 ```
 
+</details>
+
+<details>
+<summary>Groovy</summary>
+
+_build.gradle_
+
+```groovy
+buildscript {
+    repositories {
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
+    }
+    dependencies {
+        classpath "love.forte.plugin.suspend-transform:suspend-transform-plugin-gradle:$VERSION"
+    }
+}
+
+
+
+plugins {
+    id "org.jetbrains.kotlin.jvm" // or js? or multiplatform?
+    id "love.forte.plugin.suspend-transform" 
+    // other...
+}
+
+// other...
+
+// config it.
+suspendTransform {
+    enabled = true // default: true
+    includeRuntime = true // default: true
+    jvm {
+        // ...
+    }
+    js {
+        // ...
+    }
+}
+```
+
+</details>
+
 ### Maven
 
 > Not supported yet.
 
+## Cautions
+
+### Gradle JVM
+
+Gradle JVM must be JDK11+
+
+### JS platform
+
+JS platform target not supported yet. see: [KT-53993](https://youtrack.jetbrains.com/issue/KT-53993)
 
 ## Effect
 
@@ -176,7 +267,7 @@ class Bar {
 
 **compiled:**
 
-> Simplified from decompiled results.
+> _Simplified from decompiled results._
 
 ```kotlin
 import love.forte.plugin.suspendtrans.annotation.JvmAsync
@@ -286,4 +377,109 @@ class Bar {
 
     fun noTrans(): Int { /* compiled code */ }
 }
+```
+
+## Custom config
+
+```kotlin
+plugin {
+    id("love.forte.plugin.suspend-transform") version "$VERSION"
+}
+
+
+suspendTransform {
+    // enabled suspend transform plugin
+    enabled = true
+    // include 'love.forte.plugin.suspend-transform:suspend-transform-runtime' to the runtime environment
+    includeRuntime = true
+    // the configuration name for including 'love.forte.plugin.suspend-transform:suspend-transform-runtime'
+    runtimeConfigurationName = "implementation"
+    
+    // jvm platform target config
+    jvm {
+        // jvm blocking annotation. default: @JvmBlocking
+        jvmBlockingMarkAnnotation.apply {
+            annotationName = "love.forte.plugin.suspendtrans.annotation.JvmBlocking"
+            baseNameProperty = "baseName"
+            suffixProperty = "suffix"
+            asPropertyProperty = "asProperty"
+        }
+        
+        // jvm async annotation. default: @JvmAsync
+        jvmAsyncMarkAnnotation.apply {
+            annotationName = "love.forte.plugin.suspendtrans.annotation.JvmAsync"
+            baseNameProperty = "baseName"
+            suffixProperty = "suffix"
+            asPropertyProperty = "asProperty"
+        }
+
+        // jvm blocking function. 
+        // The function signature must satisfy: fun <T> <fun-name>(block: suspend () -> T): T
+        jvmBlockingFunctionName = "love.forte.plugin.suspendtrans.runtime.\$runInBlocking$"
+        
+        // jvm async function. 
+        // The function signature must satisfy: fun <T> <fun-name>(block: suspend () -> T): CompletableFuture<T>
+        jvmAsyncFunctionName = "love.forte.plugin.suspendtrans.runtime.\$runInAsync$"
+
+        // annotations that to be included to the synthetic blocking functions
+        syntheticBlockingFunctionIncludeAnnotations = listOf(
+            SuspendTransformConfiguration.IncludeAnnotation("love.forte.plugin.suspendtrans.annotation.Api4J")
+        )
+
+        // annotations that to be included to the synthetic async functions
+        syntheticAsyncFunctionIncludeAnnotations = listOf(
+            SuspendTransformConfiguration.IncludeAnnotation("love.forte.plugin.suspendtrans.annotation.Api4J")
+        )
+
+        // copy the annotations from source function to the synthetic blocking function
+        copyAnnotationsToSyntheticBlockingFunction = true
+        
+        // copy the annotations from source function to the synthetic async function
+        copyAnnotationsToSyntheticAsyncFunction = true
+
+        // if 'copyAnnotationsToSyntheticBlockingFunction == true',
+        // list of annotations to be excluded in the copy process
+        copyAnnotationsToSyntheticBlockingFunctionExcludes = listOf(
+            SuspendTransformConfiguration.ExcludeAnnotation("kotlin.jvm.JvmSynthetic")
+        )
+
+        // if 'copyAnnotationsToSyntheticAsyncFunction == true',
+        // list of annotations to be excluded in the copy process
+        copyAnnotationsToSyntheticAsyncFunctionExcludes = listOf(
+            SuspendTransformConfiguration.ExcludeAnnotation("kotlin.jvm.JvmSynthetic")
+        )
+    }
+    
+    js {
+        // Roughly similar to what is in 'jvm'
+    }
+    
+    
+}
+```
+
+## License
+
+see [LICENSE](LICENSE) .
+
+```text
+Copyright (c) 2022 ForteScarlet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
 ```

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/CliOptions.kt

@@ -59,11 +59,6 @@ object CliOptions {
             JVM_BLOCKING_MARK_ANNOTATION.option("asPropertyProperty") {
                 withProp { jvm.jvmBlockingMarkAnnotation::asPropertyProperty }
             }
-        val JVM_BLOCKING_MARK_ANNOTATION_FUNCTION_INHERITABLE =
-            JVM_BLOCKING_MARK_ANNOTATION.option("functionInheritable") {
-                inc { jvm.jvmBlockingMarkAnnotation.functionInheritable = it.toBoolean()  }
-                out { jvm.jvmBlockingMarkAnnotation.functionInheritable.toString() }
-            }
         //endregion
 
         val COPY_ANNOTATIONS_TO_SYNTHETIC_BLOCKING_FUNCTION =
@@ -114,11 +109,6 @@ object CliOptions {
             JVM_ASYNC_MARK_ANNOTATION.option("asPropertyProperty") {
                 withProp { jvm.jvmAsyncMarkAnnotation::asPropertyProperty }
             }
-        val JVM_ASYNC_MARK_ANNOTATION_FUNCTION_INHERITABLE =
-            JVM_ASYNC_MARK_ANNOTATION.option("functionInheritable") {
-                inc { jvm.jvmAsyncMarkAnnotation.functionInheritable = it.toBoolean()  }
-                out { jvm.jvmAsyncMarkAnnotation.functionInheritable.toString() }
-            }
         //endregion
 
 
@@ -157,7 +147,6 @@ object CliOptions {
         Jvm.JVM_BLOCKING_MARK_ANNOTATION_BASE_NAME_PROPERTY,
         Jvm.JVM_BLOCKING_MARK_ANNOTATION_SUFFIX_PROPERTY,
         Jvm.JVM_BLOCKING_MARK_ANNOTATION_AS_PROPERTY_PROPERTY,
-        Jvm.JVM_BLOCKING_MARK_ANNOTATION_FUNCTION_INHERITABLE,
         Jvm.COPY_ANNOTATIONS_TO_SYNTHETIC_BLOCKING_FUNCTION,
         Jvm.COPY_ANNOTATIONS_TO_SYNTHETIC_BLOCKING_FUNCTION_EXCLUDES_NAME,
         Jvm.SYNTHETIC_BLOCKING_FUNCTION_INCLUDE_ANNOTATIONS,
@@ -166,7 +155,6 @@ object CliOptions {
         Jvm.JVM_ASYNC_MARK_ANNOTATION_BASE_NAME_PROPERTY,
         Jvm.JVM_ASYNC_MARK_ANNOTATION_SUFFIX_PROPERTY,
         Jvm.JVM_ASYNC_MARK_ANNOTATION_AS_PROPERTY_PROPERTY,
-        Jvm.JVM_ASYNC_MARK_ANNOTATION_FUNCTION_INHERITABLE,
         Jvm.SYNTHETIC_ASYNC_FUNCTION_INCLUDE_ANNOTATIONS,
         Jvm.COPY_ANNOTATIONS_TO_SYNTHETIC_ASYNC_FUNCTION,
         Jvm.COPY_ANNOTATIONS_TO_SYNTHETIC_ASYNC_FUNCTION_EXCLUDES_NAME,

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/SuspendTransformConfiguration.kt

@@ -184,8 +184,6 @@ open class SuspendTransformConfiguration @JvmOverloads constructor(var enabled:
         var baseNameProperty: String = "baseName",
         var suffixProperty: String = "suffix",
         var asPropertyProperty: String = "asProperty",
-        // TODO ?
-        var functionInheritable: Boolean = false
     )
 }
 

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/utils/AnnotationDescriptorUtils.kt

@@ -38,8 +38,10 @@ data class TransformAnnotationData(
     val suffix: String?,
     val asProperty: Boolean?,
     val functionName: String,
-    val functionInheritable: Boolean,
 ) {
+    // TODO remove.
+    val functionInheritable: Boolean = false
+
     companion object {
         fun of(
             annotationDescriptor: AnnotationDescriptor,
@@ -48,7 +50,6 @@ data class TransformAnnotationData(
             annotationAsPropertyPropertyName: String = "asProperty",
             defaultBaseName: String,
             defaultSuffix: String,
-            functionInheritable: Boolean,
         ): TransformAnnotationData {
             val baseName = annotationDescriptor.argumentValue(annotationBaseNamePropertyName)
                 ?.accept(AbstractNullableAnnotationArgumentVoidDataVisitor.stringOnly, null)
@@ -66,7 +67,6 @@ data class TransformAnnotationData(
                 suffix,
                 asProperty,
                 functionName,
-                functionInheritable
             )
         }
     }
@@ -143,15 +143,12 @@ private operator fun TransformAnnotationData?.plus(other: TransformAnnotationDat
         suffix?.also(::append)
     }
 
-    val functionInheritable = other.functionInheritable.takeIf { it } ?: this.functionInheritable
-
     return TransformAnnotationData(
         annotationDescriptor = other.annotationDescriptor,
         baseName = baseName,
         suffix = suffix,
         asProperty = asProperty,
         functionName = functionName,
-        functionInheritable = functionInheritable
     )
 
 }
@@ -176,7 +173,6 @@ private fun Annotations.resolveToTransformAnnotations(
                 annotationAsPropertyPropertyName,
                 defaultBaseName,
                 defaultSuffix,
-                functionInheritable
             )
         }
     }

compiler/suspend-transform-plugin/src/test/kotlin/love/forte/plugin/suspendtrans/test/Test.kt

@@ -42,10 +42,7 @@ class Test {
         val modules = sourceModuleInfos.map {
             KotlinModule(it, componentRegistrars = listOf(SuspendTransformComponentRegistrar().apply {
                 defaultConfiguration = SuspendTransformConfiguration().apply {
-                    jvm {
-                        jvmBlockingMarkAnnotation.functionInheritable = true
-                        jvmAsyncMarkAnnotation.functionInheritable = true
-                    }
+
                 }
             })).apply {
                 compilation.apply {

plugins/suspend-transform-plugin-gradle/build.gradle.kts

@@ -21,6 +21,7 @@ buildConfig {
 
     val project = project(":compiler:suspend-transform-plugin-embeddable")
     buildConfigField("String", "KOTLIN_PLUGIN_ID", "\"${rootProject.extra["kotlin_plugin_id"]}\"")
+    buildConfigField("String", "PLUGIN_VERSION", "\"${version}\"")
     buildConfigField("String", "KOTLIN_PLUGIN_GROUP", "\"${project.group}\"")
     buildConfigField("String", "KOTLIN_PLUGIN_NAME", "\"${project.name}\"")
     buildConfigField("String", "KOTLIN_PLUGIN_VERSION", "\"${project.version}\"")