init kotlin compiler plugin

Author: stslex

app/build.gradle.kts

@@ -28,11 +28,23 @@ android {
 }
 
 dependencies {
-    coreLibraryDesugaring(libs.android.desugarJdkLibs)
+    implementation(project(":compiler-plugin-lib"))
+    kotlinCompilerPluginClasspath(project(":compiler-plugin-lib"))
 
+    coreLibraryDesugaring(libs.android.desugarJdkLibs)
     implementation(libs.androidx.activity)
     implementation(libs.androidx.lifecycle.viewModel)
     implementation(libs.androidx.lifecycle.runtime)
     implementation(libs.androidx.lifecycle.common)
     implementation(libs.androidx.constraintlayout)
 }
+
+tasks.named("build") {
+    dependsOn("pluginJar")
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+    kotlinOptions {
+        freeCompilerArgs += listOf("-Xplugin=${rootProject.projectDir}/compiler-plugin-lib/build/libs/compiler-plugin-lib.jar")
+    }
+}

app/src/main/kotlin/com/stslex/compiler_app/MainActivity.kt

@@ -9,6 +9,7 @@ import androidx.lifecycle.lifecycleScope
 import com.stslex.compiler_app.UserToastUtil.sendToastOfUserChanges
 import com.stslex.compiler_app.app.R
 import com.stslex.compiler_app.model.UserModel
+import com.stslex.compiler_plugin_lib.DistinctUntilChangeFun
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import java.util.logging.Level
@@ -52,11 +53,13 @@ class MainActivity : ComponentActivity() {
         setSecondName(user.secondName)
     }
 
+    @DistinctUntilChangeFun
     private fun setName(name: String) {
         logger.log(Level.INFO, "setName: $name")
         findViewById<TextView>(R.id.usernameFieldTextView).text = name
     }
 
+    @DistinctUntilChangeFun
     private fun setSecondName(name: String) {
         logger.log(Level.INFO, "setSecondName: $name")
         findViewById<TextView>(R.id.secondNameFieldTextView).text = name

build.gradle.kts

@@ -2,15 +2,17 @@ plugins {
     alias(libs.plugins.application) apply false
     alias(libs.plugins.kotlin) apply false
     alias(libs.plugins.library) apply false
+    alias(libs.plugins.jetbrains.kotlin.jvm) apply false
 }
 
 buildscript {
     repositories {
         google()
         mavenCentral()
+        mavenLocal()
     }
 }
 
 tasks.register(name = "type", type = Delete::class) {
     delete(rootProject.projectDir.resolve("build"))
-}
+}

compiler-plugin-lib/.gitignore

@@ -0,0 +1 @@
+/build

compiler-plugin-lib/build.gradle.kts

@@ -0,0 +1,22 @@
+plugins {
+    `java-library`
+    alias(libs.plugins.jetbrains.kotlin.jvm)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+kotlin {
+    explicitApi()
+    compilerOptions {
+        jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_21
+    }
+}
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    compileOnly(libs.jetbrains.kotlin.compiler.embeddable)
+}
+

compiler-plugin-lib/settings.gradle.kts

@@ -0,0 +1,16 @@
+enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
+
+@Suppress("UnstableApiUsage")
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "compiler-plugin-lib"

compiler-plugin-lib/src/main/kotlin/com/stslex/compiler_plugin_lib/DistinctChangeCache.kt

@@ -0,0 +1,26 @@
+package com.stslex.compiler_plugin_lib
+
+import java.util.logging.Level
+import java.util.logging.Logger
+
+internal object DistinctChangeCache {
+
+    private const val TAG = "KotlinCompilerDistinct"
+    private val logger = Logger.getLogger(TAG)
+    private val cache = mutableMapOf<String, Pair<List<Any?>, Any?>>()
+
+    @JvmStatic
+    @Suppress("UNCHECKED_CAST")
+    fun <R> invoke(key: String, args: List<Any?>, body: () -> R): R {
+        val entry = cache[key]
+        logger.log(Level.INFO, "memorize key: $key, entry: $entry, args: $args")
+
+        if (entry != null && entry.first == args) {
+            return entry.second as R
+        }
+
+        val result = body()
+        cache[key] = args to result
+        return result
+    }
+}

compiler-plugin-lib/src/main/kotlin/com/stslex/compiler_plugin_lib/DistinctUntilChangeFun.kt

@@ -0,0 +1,5 @@
+package com.stslex.compiler_plugin_lib
+
+@Target(AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.BINARY)
+public annotation class DistinctUntilChangeFun

compiler-plugin-lib/src/main/kotlin/com/stslex/compiler_plugin_lib/WorkshopCompilerPlugin.kt

@@ -0,0 +1,17 @@
+package com.stslex.compiler_plugin_lib
+
+import com.stslex.compiler_plugin_lib.extensions.DistinctChangeIrGenerationExtension
+import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
+import org.jetbrains.kotlin.config.CompilerConfiguration
+
+@OptIn(ExperimentalCompilerApi::class)
+internal class WorkshopCompilerPlugin(
+    override val supportsK2: Boolean = true
+) : CompilerPluginRegistrar() {
+
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        IrGenerationExtension.registerExtension(DistinctChangeIrGenerationExtension())
+    }
+}

compiler-plugin-lib/src/main/kotlin/com/stslex/compiler_plugin_lib/extensions/DistinctChangeIrGenerationExtension.kt

@@ -0,0 +1,17 @@
+package com.stslex.compiler_plugin_lib.extensions
+
+import com.stslex.compiler_plugin_lib.transformers.IrFunctionTransformer
+import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
+
+internal class DistinctChangeIrGenerationExtension : IrGenerationExtension {
+
+    override fun generate(
+        moduleFragment: IrModuleFragment,
+        pluginContext: IrPluginContext
+    ) {
+        moduleFragment.transformChildrenVoid(IrFunctionTransformer(pluginContext))
+    }
+}