Switch to KotlinPoet Code Generation

hooks/src/test/kotlin/com/intuit/hooks/SyncWaterfallHookTests.kt

@@ -33,8 +33,8 @@ class SyncWaterfallHookTests {
     @Test
     fun `waterfall taps work with arity 2`() {
         val h = Hook2<String, Int>()
-        h.tap("continue") { _, x, y -> "$x David" }
-        h.tap("continue again") { _, x, y -> "$x Jeremiah" }
+        h.tap("continue") { _, x, _ -> "$x David" }
+        h.tap("continue again") { _, x, _ -> "$x Jeremiah" }
 
         val result = h.call("Kian", 3)
         Assertions.assertEquals("Kian David Jeremiah", result)

processor/api/processor.api

@@ -1,7 +1,5 @@
 public final class com/intuit/hooks/plugin/ksp/HooksProcessor : com/google/devtools/ksp/processing/SymbolProcessor {
 	public fun <init> (Lcom/google/devtools/ksp/processing/CodeGenerator;Lcom/google/devtools/ksp/processing/KSPLogger;)V
-	public fun finish ()V
-	public fun onError ()V
 	public fun process (Lcom/google/devtools/ksp/processing/Resolver;)Ljava/util/List;
 }
 

processor/build.gradle.kts

@@ -1,7 +1,7 @@
 dependencies {
     implementation(libs.kotlin.stdlib)
     implementation(libs.ksp.spa)
-//    implementation(libs.ksp.poet)
+    implementation(libs.ksp.poet)
     implementation(libs.arrow.core)
 
     testImplementation(project(":hooks"))

processor/src/main/kotlin/com/intuit/hooks/plugin/codegen/HookInfo.kt

@@ -1,54 +1,62 @@
 package com.intuit.hooks.plugin.codegen
 
+import com.google.devtools.ksp.getVisibility
+import com.google.devtools.ksp.symbol.*
+import com.intuit.hooks.plugin.ksp.text
+import com.intuit.hooks.plugin.ksp.validation.HookAnnotation
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.ksp.TypeParameterResolver
+import com.squareup.kotlinpoet.ksp.toKModifier
+import com.squareup.kotlinpoet.ksp.toTypeName
+import com.squareup.kotlinpoet.ksp.toTypeParameterResolver
+
 internal data class HookMember(
     val name: String,
     val visibility: String,
 )
 
 internal data class HookSignature(
-    val text: String,
-    val isSuspend: Boolean,
-    val returnType: String,
-    /** For hooks that return a wrapped result, like [BailResult], this is the inner type */
-    val returnTypeType: String?,
+    val hookFunctionSignatureType: KSTypeReference,
+    val hookFunctionSignatureReference: KSCallableReference
 ) {
-    val nullableReturnTypeType = "${returnTypeType}${if (returnTypeType?.last() == '?') "" else "?"}"
-
-    override fun toString() = text
+    val isSuspend get() = hookFunctionSignatureType.modifiers.contains(Modifier.SUSPEND)
+    val returnTypeText get() = hookFunctionSignatureReference.returnType.text
+    val returnType get() = hookFunctionSignatureReference.returnType.toTypeName()
+    val returnTypeType
+        get() = hookFunctionSignatureReference.returnType.element?.typeArguments?.firstOrNull()?.toTypeName()!!
+    val nullableReturnTypeType get() = returnTypeType.copy(nullable = true)
+    val parameters get() = hookFunctionSignatureReference.functionParameters
+
+    override fun toString() = hookFunctionSignatureType.text
 }
 
 internal class HookParameter(
-    val name: String?,
-    val type: String,
+    val parameter: KSValueParameter,
     val position: Int,
-)
-
-internal val HookParameter.withType get() = "$withoutType: $type"
-internal val HookParameter.withoutType get() = name ?: "p$position"
+) {
+    val name: String? get() = parameter.name?.asString()
+    val type: String get() = parameter.type.text
+    val withType get() = "$withoutType: $type"
+    val withoutType get() = name ?: "p$position"
+}
 
 internal data class HookInfo(
     val property: HookMember,
     val hookType: HookType,
     val hookSignature: HookSignature,
     val params: List<HookParameter>,
+
+    val propertyDeclaration: KSPropertyDeclaration,
+    val annotation: HookAnnotation
 ) {
+    // TODO: Should this actually default to public?
+    val propertyVisibility get() = propertyDeclaration.getVisibility().toKModifier() ?: KModifier.PUBLIC
     val zeroArity = params.isEmpty()
     val isAsync = hookType.properties.contains(HookProperty.Async)
+    val parentResolver get() = (this.propertyDeclaration.parent as? KSClassDeclaration)?.typeParameters?.toTypeParameterResolver() ?: TypeParameterResolver.EMPTY
 }
 
-internal val HookInfo.tapMethod get() = if (!zeroArity) """
-    public fun tap(name: String, f: $hookSignature): String? = tap(name, generateRandomId(), f)
-    public fun tap(name: String, id: String, f: $hookSignature): String? = super.tap(name, id) { _: HookContext, $paramsWithTypes -> f($paramsWithoutTypes) }
-""".trimIndent() else ""
 internal val HookInfo.paramsWithTypes get() = params.joinToString(transform = HookParameter::withType)
 internal val HookInfo.paramsWithoutTypes get() = params.joinToString(transform = HookParameter::withoutType)
-internal fun HookInfo.generateClass() = this.hookType.generateClass(this)
-internal fun HookInfo.generateProperty() = (if (hookType == HookType.AsyncParallelBailHook) "@kotlinx.coroutines.ExperimentalCoroutinesApi\n" else "") +
-    "override val ${property.name}: $className = $className()"
-internal fun HookInfo.generateImports(): List<String> = emptyList()
-
 internal val HookInfo.superType get() = this.hookType.toString()
-
 internal val HookInfo.className get() = "${property.name.replaceFirstChar(Char::titlecase)}$superType"
-internal val HookInfo.typeParameter get() = "(${if (isAsync) "suspend " else ""}(HookContext, $paramsWithTypes) -> ${hookSignature.returnType})"
-internal val HookInfo.interceptParameter get() = "${if (isAsync) "suspend " else ""}(HookContext, $paramsWithTypes) -> Unit"

processor/src/main/kotlin/com/intuit/hooks/plugin/codegen/HookType.kt

@@ -8,112 +8,16 @@ internal sealed class HookProperty {
 }
 
 internal enum class HookType(vararg val properties: HookProperty) {
-    SyncHook {
-        override fun generateClass(info: HookInfo): String {
-            // todo: potentially protected
-            return """|${info.property.visibility} inner class ${info.className} : ${info.superType}<${info.typeParameter}>() {
-                      |    public fun call(${info.paramsWithTypes}): Unit = super.call { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-    SyncBailHook(HookProperty.Bail) {
-        override fun generateClass(info: HookInfo): String {
-            // todo: Potentially protected
-            return """|${info.property.visibility} inner class ${info.className} : ${info.superType}<${info.typeParameter}, ${info.hookSignature.returnTypeType}>() {
-                      |    public fun call(${info.paramsWithTypes}): ${info.hookSignature.nullableReturnTypeType} = super.call { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-    SyncWaterfallHook(HookProperty.Waterfall) {
-        override fun generateClass(info: HookInfo): String {
-            val accumulatorName = info.params.first().withoutType
-            return """|${info.property.visibility} inner class ${info.className} : ${info.superType}<${info.typeParameter}, ${info.params.first().type}>() {
-                      |    public fun call(${info.paramsWithTypes}): ${info.hookSignature.returnType} = super.call($accumulatorName,
-                      |        invokeTap = { f, $accumulatorName, context -> f(context, ${info.paramsWithoutTypes}) },
-                      |        invokeInterceptor = { f, context -> f(context, ${info.paramsWithoutTypes})}
-                      |    )
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    SyncLoopHook(HookProperty.Loop) {
-        override fun generateClass(info: HookInfo): String {
-            return """|${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}, ${info.interceptParameter}>() {
-                      |    public fun call(${info.paramsWithTypes}): Unit = super.call(
-                      |         invokeTap = { f, context -> f(context, ${info.paramsWithoutTypes}) },
-                      |         invokeInterceptor = { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    )
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncParallelHook(HookProperty.Async) {
-        override fun generateClass(info: HookInfo): String {
-            return """|${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}>() {
-                      |    public suspend fun call(${info.paramsWithTypes}): Unit = super.call { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncParallelBailHook(HookProperty.Async, HookProperty.Bail) {
-        override fun generateClass(info: HookInfo): String {
-            return """|@kotlinx.coroutines.ExperimentalCoroutinesApi
-                      |${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}, ${info.hookSignature.returnTypeType}>() {
-                      |    public suspend fun call(concurrency: Int, ${info.paramsWithTypes}): ${info.hookSignature.nullableReturnTypeType} = super.call(concurrency) { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncSeriesHook(HookProperty.Async) {
-        override fun generateClass(info: HookInfo): String {
-            return """|${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}>() {
-                      |    public suspend fun call(${info.paramsWithTypes}): Unit = super.call { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncSeriesBailHook(HookProperty.Async, HookProperty.Bail) {
-        override fun generateClass(info: HookInfo): String {
-            return """|${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}, ${info.hookSignature.returnTypeType}>() {
-                      |    public suspend fun call(${info.paramsWithTypes}): ${info.hookSignature.nullableReturnTypeType} = super.call { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncSeriesWaterfallHook(HookProperty.Async, HookProperty.Waterfall) {
-        override fun generateClass(info: HookInfo): String {
-            val accumulatorName = info.params.first().withoutType
-            return """|${info.property.visibility} inner class ${info.className} : ${info.superType}<${info.typeParameter}, ${info.params.first().type}>() {
-                      |    public suspend fun call(${info.paramsWithTypes}): ${info.hookSignature.returnType} = super.call($accumulatorName,
-                      |        invokeTap = { f, $accumulatorName, context -> f(context, ${info.paramsWithoutTypes}) },
-                      |        invokeInterceptor = { f, context -> f(context, ${info.paramsWithoutTypes})}
-                      |    )
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    },
-
-    AsyncSeriesLoopHook(HookProperty.Async, HookProperty.Loop) {
-        override fun generateClass(info: HookInfo): String {
-            return """|${info.property.visibility} inner class ${info.className}: ${info.superType}<${info.typeParameter}, ${info.interceptParameter}>() {
-                      |    public suspend fun call(${info.paramsWithTypes}): Unit = super.call(
-                      |         invokeTap = { f, context -> f(context, ${info.paramsWithoutTypes}) },
-                      |         invokeInterceptor = { f, context -> f(context, ${info.paramsWithoutTypes}) }
-                      |    )
-                      |    ${info.tapMethod}
-                      |}"""
-        }
-    };
-
-    abstract fun generateClass(info: HookInfo): String
+    SyncHook,
+    SyncBailHook(HookProperty.Bail),
+    SyncWaterfallHook(HookProperty.Waterfall),
+    SyncLoopHook(HookProperty.Loop),
+    AsyncParallelHook(HookProperty.Async),
+    AsyncParallelBailHook(HookProperty.Async, HookProperty.Bail),
+    AsyncSeriesHook(HookProperty.Async),
+    AsyncSeriesBailHook(HookProperty.Async, HookProperty.Bail),
+    AsyncSeriesWaterfallHook(HookProperty.Async, HookProperty.Waterfall),
+    AsyncSeriesLoopHook(HookProperty.Async, HookProperty.Loop);
 
     companion object {
         val annotationDslMarkers = values().map {