Skip to content

Commit 1aaf1e8

Browse files
ForteScarletForteScarlet
committed
feat: 更新Kotlin到v1.8.0; 调整插件的配置方式，并支持多样化的自定义配置
close #7
1 parent 656d46d commit 1aaf1e8

File tree

15 files changed

+328
-198
lines changed

15 files changed

+328
-198
lines changed

‎buildSrc/src/main/kotlin/IProject.kt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
object IProject {
2-
const val VERSION = "0.2.0"
2+
const val VERSION = "0.2.0-L.1"
33
const val GROUP = "love.forte.plugin.suspend-transform"
44
const val DESCRIPTION = "Generate platform-compatible functions for Kotlin suspend functions"
55

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

Lines changed: 40 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package love.forte.plugin.suspendtrans
22

3+
import kotlinx.serialization.builtins.ListSerializer
4+
import kotlinx.serialization.builtins.MapSerializer
35
import kotlinx.serialization.json.Json
46
import org.jetbrains.kotlin.compiler.plugin.AbstractCliOption
57
import kotlin.reflect.KMutableProperty
@@ -14,13 +16,46 @@ object CliOptions {
1416

1517
const val CONFIGURATION = "configuration"
1618

17-
private val RAW_CONFIGURATION = option(
18-
name = "raw_configuration",
19+
/** 冒号转义符 */
20+
private const val COLON_ESCAPE_CHARACTER = "&%1_"
21+
/** 逗号转义符 */
22+
private const val COMMA_ESCAPE_CHARACTER = "&%2_"
23+
24+
private val rawRegex = Regex("[:,]")
25+
private val encodeRegex = Regex("(&%1_|&%2_)")
26+
27+
28+
private val TRANSFORMERS = option(
29+
name = "transformers",
1930
valueDescription = "Serialize the results in JSON format for configuration information",
2031
description = "Serialize the results in JSON format for configuration information",
2132
) {
22-
inc { defaultJson.decodeFromString(SuspendTransformConfiguration.serializer(), it) }
23-
out { defaultJson.encodeToString(SuspendTransformConfiguration.serializer(), this) }
33+
// MutableMap<TargetPlatform, MutableList<Transformer>>
34+
val serializer = MapSerializer(TargetPlatform.serializer(), ListSerializer(Transformer.serializer()))
35+
36+
inc {
37+
val jsonStr = encodeRegex.replace(it) { result ->
38+
when (val value = result.value) {
39+
COLON_ESCAPE_CHARACTER -> ":"
40+
COMMA_ESCAPE_CHARACTER -> ","
41+
else -> value
42+
}
43+
}
44+
45+
transformers = defaultJson.decodeFromString(serializer, jsonStr).toMutableMap()
46+
}
47+
out {
48+
val encoded = defaultJson.encodeToString(serializer, this.transformers)
49+
50+
rawRegex.replace(encoded) { result ->
51+
when (val value = result.value) {
52+
":" -> COLON_ESCAPE_CHARACTER
53+
"," -> COMMA_ESCAPE_CHARACTER
54+
else -> value
55+
}
56+
}
57+
58+
}
2459
}
2560

2661
private val ENABLED = option("enabled") {
@@ -31,7 +66,7 @@ object CliOptions {
3166

3267
val allOptions: List<ICliOption> = listOf(
3368
ENABLED,
34-
RAW_CONFIGURATION
69+
TRANSFORMERS
3570
)
3671
val allOptionsMap = allOptions.associateBy { it.oName }
3772

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

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -36,35 +36,5 @@ class SuspendTransformCommandLineProcessor : CommandLineProcessor {
3636
}
3737

3838
CliOptions.allOptionsMap[option.optionName]?.resolveFromValue(getConf(), value)
39-
//
40-
// when (option.optionName) {
41-
// CliOptions.ENABLED.optionName -> inConf { enabled = value.toBoolean() }
42-
// CliOptions.Jvm.JVM_BLOCKING_FUNCTION_NAME.optionName -> inConf {
43-
// jvm { jvmBlockingFunctionName = value }
44-
// }
45-
//
46-
// CliOptions.Jvm.JVM_ASYNC_FUNCTION_NAME.optionName -> inConf {
47-
// jvm { jvmAsyncFunctionName = value }
48-
// }
49-
//
50-
// CliOptions.Jvm.JVM_BLOCKING_MARK_ANNOTATION_ANNOTATION_NAME.optionName -> inConf {
51-
// jvm { jvmBlockingMarkAnnotation.annotationName = value }
52-
// }
53-
//
54-
// CliOptions.Jvm.JVM_BLOCKING_MARK_ANNOTATION_BASE_NAME_PROPERTY.optionName -> inConf {
55-
// jvm { jvmBlockingMarkAnnotation.baseNameProperty = value }
56-
// }
57-
//
58-
// CliOptions.Jvm.JVM_BLOCKING_MARK_ANNOTATION_SUFFIX_PROPERTY.optionName -> inConf {
59-
// jvm { jvmBlockingMarkAnnotation.suffixProperty = value }
60-
// }
61-
//
62-
// CliOptions.Jvm.JVM_BLOCKING_MARK_ANNOTATION_AS_PROPERTY_PROPERTY.optionName -> inConf {
63-
// jvm { jvmBlockingMarkAnnotation.asPropertyProperty = value }
64-
// }
65-
//
66-
//
67-
// else -> System.err.println("Unexpected config option ${option.optionName}")
68-
// }
6939
}
7040
}

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

Lines changed: 137 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ data class ClassInfo @JvmOverloads constructor(
1818

1919
@Serializable
2020
enum class TargetPlatform {
21-
JVM, JS
21+
COMMON, JVM, JS
2222
}
2323

2424
/**
@@ -55,6 +55,7 @@ data class Transformer(
5555
*/
5656
val transformFunctionInfo: FunctionInfo,
5757

58+
5859
/**
5960
* 转化后的返回值类型, 为null时代表与原函数一致。
6061
*/
@@ -128,122 +129,164 @@ data class IncludeAnnotation(
128129
*
129130
* @author ForteScarlet
130131
*/
132+
@Suppress("unused")
131133
@Serializable
132134
open class SuspendTransformConfiguration {
133135
var enabled: Boolean = true
134136

135-
var transformers: MutableMap<TargetPlatform, MutableList<Transformer>> =
136-
LinkedHashMap<TargetPlatform, MutableList<Transformer>>().apply {
137-
// jvm
138-
val jvmOriginFunctionIncludeAnnotations = listOf(
139-
IncludeAnnotation(ClassInfo("kotlin.jvm", "JvmSynthetic"))
140-
)
141-
142-
val jvmCopyExcludes = listOf(
143-
ClassInfo("kotlin.jvm", "JvmSynthetic")
144-
)
145-
146-
val jvmSyntheticFunctionIncludeAnnotations = listOf(
147-
IncludeAnnotation(ClassInfo("love.forte.plugin.suspendtrans.annotation", "Api4J"))
148-
)
149-
150-
// jvm to blocking
151-
val jvmBlockingMarkAnnotationClassInfo =
152-
ClassInfo("love.forte.plugin.suspendtrans.annotation", "JvmBlocking")
153-
val jvmBlockingAnnotationInfo = MarkAnnotation(jvmBlockingMarkAnnotationClassInfo)
154-
val jvmBlockingTransformFunction = FunctionInfo(
155-
JVM_RUN_IN_BLOCKING_FUNCTION_PACKAGE_NAME,
156-
JVM_RUN_IN_BLOCKING_FUNCTION_CLASS_NAME,
157-
JVM_RUN_IN_BLOCKING_FUNCTION_FUNCTION_NAME,
158-
)
159-
160-
val jvmBlockingTransformer = Transformer(
161-
markAnnotation = jvmBlockingAnnotationInfo,
162-
transformFunctionInfo = jvmBlockingTransformFunction,
163-
transformReturnType = null,
164-
transformReturnTypeGeneric = false,
165-
originFunctionIncludeAnnotations = jvmOriginFunctionIncludeAnnotations,
166-
copyAnnotationsToSyntheticFunction = true,
167-
copyAnnotationExcludes = jvmCopyExcludes,
168-
syntheticFunctionIncludeAnnotations = jvmSyntheticFunctionIncludeAnnotations
169-
)
170-
// jvm to async
171-
172-
val jvmAsyncMarkAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "JvmAsync")
173-
val jvmAsyncAnnotationInfo = MarkAnnotation(jvmAsyncMarkAnnotationClassInfo)
174-
val jvmAsyncTransformFunction = FunctionInfo(
175-
JVM_RUN_IN_ASYNC_FUNCTION_PACKAGE_NAME,
176-
JVM_RUN_IN_ASYNC_FUNCTION_CLASS_NAME,
177-
JVM_RUN_IN_ASYNC_FUNCTION_FUNCTION_NAME,
178-
)
179-
180-
val jvmAsyncTransformer = Transformer(
181-
markAnnotation = jvmAsyncAnnotationInfo,
182-
transformFunctionInfo = jvmAsyncTransformFunction,
183-
transformReturnType = ClassInfo("java.util.concurrent", "CompletableFuture"),
184-
transformReturnTypeGeneric = true,
185-
originFunctionIncludeAnnotations = jvmOriginFunctionIncludeAnnotations,
186-
copyAnnotationsToSyntheticFunction = true,
187-
copyAnnotationExcludes = jvmCopyExcludes,
188-
syntheticFunctionIncludeAnnotations = jvmSyntheticFunctionIncludeAnnotations
189-
)
190-
191-
put(TargetPlatform.JVM, mutableListOf(jvmBlockingTransformer, jvmAsyncTransformer))
192-
193-
194-
// js to async
195-
val jsSyntheticFunctionIncludeAnnotations = listOf(
196-
IncludeAnnotation(ClassInfo("love.forte.plugin.suspendtrans.annotation", "Api4Js"))
197-
)
198-
199-
val jsAsyncMarkAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "JsPromise")
200-
val jsAsyncAnnotationInfo = MarkAnnotation(jsAsyncMarkAnnotationClassInfo)
201-
val jsAsyncTransformFunction = FunctionInfo(
202-
JS_RUN_IN_ASYNC_FUNCTION_PACKAGE_NAME,
203-
JS_RUN_IN_ASYNC_FUNCTION_CLASS_NAME,
204-
JS_RUN_IN_ASYNC_FUNCTION_FUNCTION_NAME,
205-
)
206-
207-
val jsPromiseTransformer = Transformer(
208-
markAnnotation = jsAsyncAnnotationInfo,
209-
transformFunctionInfo = jsAsyncTransformFunction,
210-
transformReturnType = ClassInfo("kotlin.js", "Promise"),
211-
transformReturnTypeGeneric = true,
212-
originFunctionIncludeAnnotations = listOf(),
213-
copyAnnotationsToSyntheticFunction = true,
214-
copyAnnotationExcludes = listOf(),
215-
syntheticFunctionIncludeAnnotations = jsSyntheticFunctionIncludeAnnotations
216-
)
217-
218-
put(TargetPlatform.JS, mutableListOf(jsPromiseTransformer))
219-
}
137+
var transformers: MutableMap<TargetPlatform, List<Transformer>> = mutableMapOf()
138+
139+
fun clear() {
140+
transformers.clear()
141+
}
142+
143+
fun useJvmDefault() {
144+
transformers[TargetPlatform.JVM] = mutableListOf(jvmBlockingTransformer, jvmAsyncTransformer)
145+
}
146+
147+
fun useJsDefault() {
148+
transformers[TargetPlatform.JS] = mutableListOf(jsPromiseTransformer)
149+
}
150+
151+
fun useDefault() {
152+
useJvmDefault()
153+
useJsDefault()
154+
}
220155

221156
fun addTransformers(target: TargetPlatform, vararg transformers: Transformer) {
222-
this.transformers.computeIfAbsent(target) { mutableListOf() }.addAll(transformers)
157+
this.transformers.compute(target) { _, list ->
158+
if (list != null) {
159+
list + transformers
160+
} else {
161+
listOf(elements = transformers)
162+
}
163+
}
223164
}
224165

225166
fun addTransformers(target: TargetPlatform, transformers: Collection<Transformer>) {
226-
this.transformers.computeIfAbsent(target) { mutableListOf() }.addAll(transformers)
167+
this.transformers.compute(target) { _, list ->
168+
if (list != null) {
169+
list + transformers
170+
} else {
171+
transformers.toList()
172+
}
173+
}
227174
}
228175

229-
fun jvmTransformers(vararg transformers: Transformer) {
176+
fun addJvmTransformers(vararg transformers: Transformer) {
230177
addTransformers(target = TargetPlatform.JVM, transformers = transformers)
231178
}
232179

233-
fun jsTransformers(vararg transformers: Transformer) {
234-
addTransformers(target = TargetPlatform.JS, transformers = transformers)
180+
fun addJvmTransformers(transformers: Collection<Transformer>) {
181+
addTransformers(target = TargetPlatform.JVM, transformers = transformers)
235182
}
236183

237-
fun jvmTransformers(transformers: Collection<Transformer>) {
238-
addTransformers(target = TargetPlatform.JVM, transformers = transformers)
184+
fun addJsTransformers(vararg transformers: Transformer) {
185+
addTransformers(target = TargetPlatform.JS, transformers = transformers)
239186
}
240187

241-
fun jsTransformers(transformers: Collection<Transformer>) {
188+
fun addJsTransformers(transformers: Collection<Transformer>) {
242189
addTransformers(target = TargetPlatform.JS, transformers = transformers)
243190
}
244191

245192
override fun toString(): String {
246193
return "SuspendTransformConfiguration(enabled=$enabled, transformers=$transformers)"
247194
}
195+
196+
companion object {
197+
//region JVM defaults
198+
@JvmStatic
199+
val jvmSyntheticClassInfo = ClassInfo("kotlin.jvm", "JvmSynthetic")
200+
201+
@JvmStatic
202+
val jvmApi4JAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "Api4J")
203+
//endregion
204+
205+
//region JVM blocking defaults
206+
207+
@JvmStatic
208+
val jvmBlockingMarkAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "JvmBlocking")
209+
210+
@JvmStatic
211+
val jvmBlockingAnnotationInfo = MarkAnnotation(jvmBlockingMarkAnnotationClassInfo, defaultSuffix = "Blocking")
212+
213+
@JvmStatic
214+
val jvmBlockingTransformFunction = FunctionInfo(
215+
JVM_RUN_IN_BLOCKING_FUNCTION_PACKAGE_NAME,
216+
JVM_RUN_IN_BLOCKING_FUNCTION_CLASS_NAME,
217+
JVM_RUN_IN_BLOCKING_FUNCTION_FUNCTION_NAME,
218+
)
219+
220+
@JvmStatic
221+
val jvmBlockingTransformer = Transformer(
222+
markAnnotation = jvmBlockingAnnotationInfo,
223+
transformFunctionInfo = jvmBlockingTransformFunction,
224+
transformReturnType = null,
225+
transformReturnTypeGeneric = false,
226+
originFunctionIncludeAnnotations = listOf(IncludeAnnotation(jvmSyntheticClassInfo)),
227+
copyAnnotationsToSyntheticFunction = true,
228+
copyAnnotationExcludes = listOf(jvmSyntheticClassInfo),
229+
syntheticFunctionIncludeAnnotations = listOf(IncludeAnnotation(jvmApi4JAnnotationClassInfo))
230+
)
231+
//endregion
232+
233+
//region JVM async defaults
234+
@JvmStatic
235+
val jvmAsyncMarkAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "JvmAsync")
236+
237+
@JvmStatic
238+
val jvmAsyncAnnotationInfo = MarkAnnotation(jvmAsyncMarkAnnotationClassInfo, defaultSuffix = "Async")
239+
240+
@JvmStatic
241+
val jvmAsyncTransformFunction = FunctionInfo(
242+
JVM_RUN_IN_ASYNC_FUNCTION_PACKAGE_NAME,
243+
JVM_RUN_IN_ASYNC_FUNCTION_CLASS_NAME,
244+
JVM_RUN_IN_ASYNC_FUNCTION_FUNCTION_NAME,
245+
)
246+
247+
@JvmStatic
248+
val jvmAsyncTransformer = Transformer(
249+
markAnnotation = jvmAsyncAnnotationInfo,
250+
transformFunctionInfo = jvmAsyncTransformFunction,
251+
transformReturnType = ClassInfo("java.util.concurrent", "CompletableFuture"),
252+
transformReturnTypeGeneric = true,
253+
originFunctionIncludeAnnotations = listOf(IncludeAnnotation(jvmSyntheticClassInfo)),
254+
copyAnnotationsToSyntheticFunction = true,
255+
copyAnnotationExcludes = listOf(jvmSyntheticClassInfo),
256+
syntheticFunctionIncludeAnnotations = listOf(IncludeAnnotation(jvmApi4JAnnotationClassInfo))
257+
)
258+
//endregion
259+
260+
//region JS defaults
261+
@JvmStatic
262+
val jsApi4JsAnnotationInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "Api4Js")
263+
264+
@JvmStatic
265+
val jsAsyncMarkAnnotationClassInfo = ClassInfo("love.forte.plugin.suspendtrans.annotation", "JsPromise")
266+
267+
@JvmStatic
268+
val jsAsyncAnnotationInfo = MarkAnnotation(jsAsyncMarkAnnotationClassInfo, defaultSuffix = "Async")
269+
270+
@JvmStatic
271+
val jsAsyncTransformFunction = FunctionInfo(
272+
JS_RUN_IN_ASYNC_FUNCTION_PACKAGE_NAME,
273+
JS_RUN_IN_ASYNC_FUNCTION_CLASS_NAME,
274+
JS_RUN_IN_ASYNC_FUNCTION_FUNCTION_NAME,
275+
)
276+
277+
@JvmStatic
278+
val jsPromiseTransformer = Transformer(
279+
markAnnotation = jsAsyncAnnotationInfo,
280+
transformFunctionInfo = jsAsyncTransformFunction,
281+
transformReturnType = ClassInfo("kotlin.js", "Promise"),
282+
transformReturnTypeGeneric = true,
283+
originFunctionIncludeAnnotations = listOf(),
284+
copyAnnotationsToSyntheticFunction = true,
285+
copyAnnotationExcludes = listOf(),
286+
syntheticFunctionIncludeAnnotations = listOf(IncludeAnnotation(jsApi4JsAnnotationInfo))
287+
)
288+
//endregion
289+
290+
}
248291
}
249292

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,7 @@ const val JVM_RUN_IN_BLOCKING_FUNCTION_PACKAGE_NAME: String = "love.forte.plugin
5252
val JVM_RUN_IN_BLOCKING_FUNCTION_CLASS_NAME: String? = null
5353

5454
const val JVM_RUN_IN_BLOCKING_FUNCTION_FUNCTION_NAME: String = "\$runInBlocking\$"
55+
5556
//endregion
5657

5758

0 commit comments

Comments
 (0)