Add KSP-based @Patch annotation processor

maiatoday · maiatoday · commit 03252f5e3294 · 2025-08-10T22:01:22.000+02:00
Add `patch-processor` dependency to build script
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -3,6 +3,7 @@ plugins {
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)
     alias(libs.plugins.kotlin.parcelize)
+    alias(libs.plugins.ksp)
 }
 
 android {
@@ -56,6 +57,12 @@ dependencies {
     implementation(libs.androidx.adaptive)
     implementation(libs.androidx.adaptive.layout)
     implementation(libs.androidx.adaptive.navigation)
+
+    // Patch annotations + processor
+    implementation(project(":patch-annotations"))
+    implementation(project(":patch-processor"))
+    ksp(project(":patch-processor"))
+
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
diff --git a/app/src/main/java/de/berlindroid/zepatch/Holzmesser.kt b/app/src/main/java/de/berlindroid/zepatch/Holzmesser.kt
@@ -1,8 +1,6 @@
 package de.berlindroid.zepatch
 
-import androidx.compose.foundation.text.BasicText
-import androidx.compose.runtime.Composable
-import de.berlindroid.zepatch.patchable.Demo
+import de.berlindroid.zepatch.generated.PatchRegistry
 
 /**
  * It's like Dagger, but way worse.
@@ -11,24 +9,5 @@ import de.berlindroid.zepatch.patchable.Demo
  * hand-witten.
  */
 
-val patchables = mapOf<String, @Composable () -> Unit>(
-    "Testing1" to { BasicText("123") },
-    "Testing2" to { BasicText("123") },
-    "Testing3" to { BasicText("123") },
-    "Testing4" to { BasicText("123") },
-    "Testing5" to { BasicText("123") },
-    "Testing6" to { BasicText("123") },
-    "Testing7" to { BasicText("123") },
-    "Testing8" to { BasicText("123") },
-    "Testing9" to { BasicText("123") },
-    "Testing10" to { BasicText("123") },
-    "Testing11" to { BasicText("123") },
-    "Testing12" to { BasicText("123") },
-    "Testing13" to { BasicText("123") },
-    "Testing14" to { BasicText("123") },
-    "Testing15" to { BasicText("123") },
-    "Testing16" to { BasicText("123") },
-    "Testing17" to { BasicText("123") },
-    "Testing19" to { BasicText("123") },
-    "Demo" to { Demo() },
-)
+// Generated via @Patch + KSP
+val patchables = PatchRegistry.patchables
diff --git a/app/src/main/java/de/berlindroid/zepatch/patchable/Demo.kt b/app/src/main/java/de/berlindroid/zepatch/patchable/Demo.kt
@@ -7,7 +7,9 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import de.berlindroid.zepatch.annotations.Patch
 
+@Patch("Demo")
 @Composable
 fun Demo(
     modifier: Modifier = Modifier,
@@ -17,6 +19,16 @@ fun Demo(
     }
 }
 
+@Patch("Demo2")
+@Composable
+fun Demo2(
+    modifier: Modifier = Modifier,
+) {
+    SafeArea {
+        Text("Another Demo")
+    }
+}
+
 // TODO: share this?
 @Composable
 fun SafeArea(
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -4,4 +4,5 @@ plugins {
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
     alias(libs.plugins.kotlin.parcelize) apply false
+    alias(libs.plugins.kotlin.jvm) apply false
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -1,6 +1,7 @@
 [versions]
 agp = "8.11.0"
 kotlin = "2.2.0"
+ksp = "2.2.0-2.0.2"
 coreKtx = "1.16.0"
 junit = "4.13.2"
 junitVersion = "1.2.1"
@@ -10,6 +11,8 @@ activityCompose = "1.10.1"
 composeBom = "2025.06.01"
 
 [libraries]
+kotlinpoet = { group = "com.squareup", name = "kotlinpoet", version = "2.1.0" }
+symbol-processing-api = { group = "com.google.devtools.ksp", name = "symbol-processing-api", version.ref = "ksp" }
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
@@ -33,4 +36,6 @@ android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 
diff --git a/patch-annotations/.gitignore b/patch-annotations/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/patch-annotations/build.gradle.kts b/patch-annotations/build.gradle.kts
@@ -0,0 +1,11 @@
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+dependencies {
+    // no runtime deps needed
+}
diff --git a/patch-annotations/src/main/kotlin/de/berlindroid/zepatch/annotations/Patch.kt b/patch-annotations/src/main/kotlin/de/berlindroid/zepatch/annotations/Patch.kt
@@ -0,0 +1,7 @@
+package de.berlindroid.zepatch.annotations
+
+@Target(AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.SOURCE)
+annotation class Patch(
+    val name: String = ""
+)
diff --git a/patch-processor/.gitignore b/patch-processor/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/patch-processor/build.gradle.kts b/patch-processor/build.gradle.kts
@@ -0,0 +1,13 @@
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+dependencies {
+    implementation(project(":patch-annotations"))
+    implementation(libs.symbol.processing.api)
+    implementation(libs.kotlinpoet)
+}
diff --git a/patch-processor/src/main/kotlin/de/berlindroid/zepatch/processor/PatchProcessorProvider.kt b/patch-processor/src/main/kotlin/de/berlindroid/zepatch/processor/PatchProcessorProvider.kt
@@ -0,0 +1,11 @@
+package de.berlindroid.zepatch.processor
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+class PatchProcessorProvider : SymbolProcessorProvider {
+    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
+        return PatchSymbolProcessor(environment)
+    }
+}
diff --git a/patch-processor/src/main/kotlin/de/berlindroid/zepatch/processor/PatchSymbolProcessor.kt b/patch-processor/src/main/kotlin/de/berlindroid/zepatch/processor/PatchSymbolProcessor.kt
@@ -0,0 +1,106 @@
+package de.berlindroid.zepatch.processor
+
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getAnnotationsByType
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Dependencies
+import com.google.devtools.ksp.processing.KSPLogger
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSFunctionDeclaration
+import com.google.devtools.ksp.symbol.Origin
+import com.google.devtools.ksp.validate
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.MemberName
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.asTypeName
+import com.squareup.kotlinpoet.AnnotationSpec
+import com.squareup.kotlinpoet.LambdaTypeName
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import de.berlindroid.zepatch.annotations.Patch
+
+class PatchSymbolProcessor(
+    private val environment: com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+) : SymbolProcessor {
+    private val logger: KSPLogger = environment.logger
+    private val codeGenerator: CodeGenerator = environment.codeGenerator
+
+    @OptIn(KspExperimental::class)
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        val patchAnnotation = Patch::class
+        val symbols = resolver.getSymbolsWithAnnotation(patchAnnotation.qualifiedName!!).toList()
+
+        val patchFunctions = symbols.filterIsInstance<KSFunctionDeclaration>().filter { it.validate() }
+
+        if (patchFunctions.isEmpty()) return emptyList()
+
+        // Build map entries
+        val entries = patchFunctions.mapNotNull { funDecl ->
+            val pkgName = funDecl.packageName.asString()
+            val simpleName = funDecl.simpleName.asString()
+            val ann = funDecl.getAnnotationsByType(Patch::class).firstOrNull()
+            val key = ann?.name?.takeIf { it.isNotBlank() } ?: simpleName
+
+            // Build FQ function call reference
+            val fqName = "$pkgName.$simpleName"
+            MapEntry(key, fqName)
+        }
+
+        generateRegistry(entries)
+        return emptyList()
+    }
+
+    private fun generateRegistry(entries: List<MapEntry>) {
+        val packageName = "de.berlindroid.zepatch.generated"
+        val objectName = "PatchRegistry"
+        val composableAnnotation = ClassName("androidx.compose.runtime", "Composable")
+
+        val unitComposable = CodeBlock.of("@%T () -> Unit", composableAnnotation)
+        val mapType = com.squareup.kotlinpoet.MAP.parameterizedBy(
+            String::class.asTypeName(),
+            LambdaTypeName.get(returnType = Unit::class.asTypeName()).copy(
+                annotations = listOf(AnnotationSpec.builder(composableAnnotation).build())
+            )
+        )
+
+        val mapInitializer = CodeBlock.builder().apply {
+            add("mapOf(\n")
+            entries.forEachIndexed { idx, e ->
+                val sep = if (idx < entries.size - 1) "," else ""
+                add("    %S to { %L() }%L\n", e.key, e.fqFunctionCall, sep)
+            }
+            add(")")
+        }.build()
+
+        val property = PropertySpec.builder("patchables", mapType, KModifier.PUBLIC)
+            .initializer(mapInitializer)
+            .build()
+
+        val type = TypeSpec.objectBuilder(objectName)
+            .addKdoc("Generated by KSP. Do not modify.")
+            .addProperty(property)
+            .build()
+
+        val file = FileSpec.builder(packageName, objectName)
+            .addType(type)
+            .build()
+
+        val fileBytes = file.toString().toByteArray()
+        codeGenerator.createNewFile(
+            Dependencies(aggregating = true, *emptyArray()),
+            packageName,
+            objectName
+        ).use { out ->
+            out.write(fileBytes)
+        }
+    }
+
+    data class MapEntry(val key: String, val fqFunctionCall: String)
+}
diff --git a/patch-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider b/patch-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
@@ -0,0 +1 @@
+de.berlindroid.zepatch.processor.PatchProcessorProvider
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -21,3 +21,5 @@ dependencyResolutionManagement {
 
 rootProject.name = "ZePatch"
 include(":app")
+include(":patch-annotations")
+include(":patch-processor")

Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@ plugins {`
`4`	`4`	`alias(libs.plugins.kotlin.android) apply false`
`5`	`5`	`alias(libs.plugins.kotlin.compose) apply false`
`6`	`6`	`alias(libs.plugins.kotlin.parcelize) apply false`
	`7`	`+ alias(libs.plugins.kotlin.jvm) apply false`
`7`	`8`	`}`