Use a custom registrar to invoke KSP

This commit gets rid of classpath generation and instead just uses a custom registrar
to register and implementation of  where
plugins are pre-defined.

I've also changed the symbol processors to be a list similar to KAPT and also added an
extension property to get the folder where generated KSP code is kept

Author: yigit

README.md

@@ -124,6 +124,7 @@ To test KSP processors, you need to add a dependency to the ksp module:
 
 ```Groovy
 dependencies {
+    implementation 'com.github.tschuchortdev:kotlin-compile-testing:1.2.9'
     implementation 'com.github.tschuchortdev:kotlin-compile-testing-ksp:1.2.9'
 }
 ```
@@ -134,12 +135,14 @@ This module adds a new function to the `KotlinCompilation` to specify KSP proces
 class MySymbolProcessor : SymbolProcessor {
     // implementation of the SymbolProcessor from the KSP API
 }
-
-val result = KotlinCompilation().apply {
+val compilation = KotlinCompilation().apply {
     sources = listOf(source)
-    symbolProcessors(MySymbolProcessor::class.java)
-}.compile()
+    symbolProcessors = listOf(MySymbolProcessor())
+}
+val result = compilation.compile()
 ```
+All code generated by the KSP processor will be written into the `KotlinCompilation.kspSourcesDir` directory.
+
 
 ## Projects that use Kotlin-Compile-Testing
 

ksp/src/main/kotlin/com/tschuchort/compiletesting/Ksp.kt

@@ -3,66 +3,96 @@
  */
 package com.tschuchort.compiletesting
 
-import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingCommandLineProcessor
-import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingComponentRegistrar
+import org.jetbrains.kotlin.com.intellij.mock.MockProject
+import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ksp.AbstractKotlinSymbolProcessingExtension
+import org.jetbrains.kotlin.ksp.KspOptions
 import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.io.File
 
-private const val KSP_PLUGIN_ID = "org.jetbrains.kotlin.ksp"
-
-private fun KotlinCompilation.initAndGetKspConfig(): KspConfiguration {
-    val config = KspConfiguration(workingDir.resolve("ksp"))
-    if (config.workingDir.exists()) {
-        // already configured, just return
-        return config
+/**
+ * The list of symbol processors for the kotlin compilation.
+ * https://goo.gle/ksp
+ */
+var KotlinCompilation.symbolProcessors: List<SymbolProcessor>
+    get() = getKspRegistrar().processors
+    set(value) {
+        val registrar = getKspRegistrar()
+        registrar.processors = value
     }
-    config.classesOutDir.mkdirs()
-    config.sourcesOurDir.mkdirs()
-    config.syntheticSources.mkdirs()
-    val kspOptions = listOf(
-        PluginOption(KSP_PLUGIN_ID, "apclasspath", config.syntheticSources.path),
-        PluginOption(KSP_PLUGIN_ID, "classes", config.classesOutDir.path),
-        PluginOption(KSP_PLUGIN_ID, "sources", config.sourcesOurDir.path)
-    )
-    compilerPlugins = compilerPlugins + KotlinSymbolProcessingComponentRegistrar()
-    commandLineProcessors = commandLineProcessors + listOf(KotlinSymbolProcessingCommandLineProcessor())
-    pluginOptions = pluginOptions + kspOptions
-    return config
-}
 
-fun KotlinCompilation.symbolProcessors(
-    vararg processors: Class<out SymbolProcessor>
+/**
+ * The directory where generates KSP sources are written
+ */
+val KotlinCompilation.kspSourcesDir: File
+    get() = kspWorkingDir.resolve("sources")
+
+/**
+ * The working directory for KSP
+ */
+private val KotlinCompilation.kspWorkingDir: File
+    get() = workingDir.resolve("ksp")
+
+/**
+ * The directory where compiled KSP classes are written
+ */
+// TODO this seems to be ignored by KSP and it is putting classes into regular classes directory
+//  but we still need to provide it in the KSP options builder as it is required
+//  once it works, we should make the property public.
+private val KotlinCompilation.kspClassesDir: File
+    get() = kspWorkingDir.resolve("classes")
+
+/**
+ * Custom subclass of [AbstractKotlinSymbolProcessingExtension] where processors are pre-defined instead of being
+ * loaded via ServiceLocator.
+ */
+private class KspTestExtension(
+    options: KspOptions,
+    private val processors: List<SymbolProcessor>
+) : AbstractKotlinSymbolProcessingExtension(
+    options = options,
+    testMode = false
 ) {
-    check(processors.isNotEmpty()) {
-        "Must provide at least 1 symbol processor"
-    }
-    val config = initAndGetKspConfig()
+    override fun loadProcessors() = processors
+}
 
-    // create a fake classpath that references our symbol processor
-    config.syntheticSources.apply {
-        resolve("META-INF/services/org.jetbrains.kotlin.ksp.processing.SymbolProcessor").apply {
-            parentFile.mkdirs()
-            // keep existing ones in case this function is called multiple times
-            val existing = if (exists()) {
-                readLines(Charsets.UTF_8)
-            } else {
-                emptyList()
+/**
+ * Registers the [KspTestExtension] to load the given list of processors.
+ */
+private class KspCompileTestingComponentRegistrar(
+    private val compilation: KotlinCompilation
+) : ComponentRegistrar {
+    var processors = emptyList<SymbolProcessor>()
+    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+        if (processors.isEmpty()) {
+            return
+        }
+        val options = KspOptions.Builder().apply {
+            this.classesOutputDir = compilation.kspClassesDir.also {
+                it.deleteRecursively()
+                it.mkdirs()
             }
-            val processorNames = existing + processors.map {
-                it.typeName
+            this.sourcesOutputDir = compilation.kspSourcesDir.also {
+                it.deleteRecursively()
+                it.mkdirs()
             }
-            writeText(
-                processorNames.joinToString(System.lineSeparator())
-            )
-        }
+        }.build()
+        val registrar = KspTestExtension(options, processors)
+        AnalysisHandlerExtension.registerExtension(project, registrar)
     }
-    this.kaptSourceDir
 }
 
-private data class KspConfiguration(
-    val workingDir: File
-) {
-    val classesOutDir = workingDir.resolve("classesOutput")
-    val sourcesOurDir = workingDir.resolve("sourcesOutput")
-    val syntheticSources = workingDir.resolve("synthetic-ksp-service")
+/**
+ * Gets the test registrar from the plugin list or adds if it does not exist.
+ */
+private fun KotlinCompilation.getKspRegistrar(): KspCompileTestingComponentRegistrar {
+    compilerPlugins.firstIsInstanceOrNull<KspCompileTestingComponentRegistrar>()?.let {
+        return it
+    }
+    val kspRegistrar = KspCompileTestingComponentRegistrar(this)
+    compilerPlugins = compilerPlugins + kspRegistrar
+    return kspRegistrar
 }

ksp/src/test/kotlin/com/tschuchort/compiletesting/AbstractSymbolProcessor.kt renamed to ksp/src/test/kotlin/com/tschuchort/compiletesting/AbstractTestSymbolProcessor.kt

@@ -4,7 +4,10 @@ import org.jetbrains.kotlin.ksp.processing.CodeGenerator
 import org.jetbrains.kotlin.ksp.processing.Resolver
 import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
 
-internal open class AbstractSymbolProcessor : SymbolProcessor {
+/**
+ * Helper class to write tests, only used in Ksp Compile Testing tests, not a public API.
+ */
+internal open class AbstractTestSymbolProcessor : SymbolProcessor {
     protected lateinit var codeGenerator: CodeGenerator
     override fun finish() {
     }

ksp/src/test/kotlin/com/tschuchort/compiletesting/DelegatingSymbolProcessorRule.kt

@@ -8,37 +8,33 @@ import org.assertj.core.api.Assertions.assertThat
 import org.jetbrains.kotlin.ksp.processing.Resolver
 import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
 import org.jetbrains.kotlin.ksp.symbol.KSClassDeclaration
-import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
+import org.mockito.Mockito.`when`
 
 @RunWith(JUnit4::class)
 class KspTest {
-    @Rule
-    @JvmField
-    val processorRule = DelegatingSymbolProcessorRule()
-
     @Test
     fun failedKspTest() {
+        val instance = mock<SymbolProcessor>()
+        `when`(instance.process(any())).thenThrow(
+            RuntimeException("intentional fail")
+        )
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessors(processorRule.delegateTo(object : AbstractSymbolProcessor() {
-                override fun process(resolver: Resolver) {
-                    throw RuntimeException("intentional fail")
-                }
-            }))
+            symbolProcessors = listOf(instance)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.INTERNAL_ERROR)
         assertThat(result.messages).contains("intentional fail")
     }
 
     @Test
-    fun processorIsCalled() {
+    fun allProcessorMethodsAreCalled() {
         val instance = mock<SymbolProcessor>()
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessors(processorRule.delegateTo(instance))
+            symbolProcessors = listOf(instance)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
         instance.inOrder {
@@ -69,7 +65,7 @@ class KspTest {
             }
         """.trimIndent()
         )
-        val processor = object : AbstractSymbolProcessor() {
+        val processor = object : AbstractTestSymbolProcessor() {
             override fun process(resolver: Resolver) {
                 val symbols = resolver.getSymbolsWithAnnotation("foo.bar.TestAnnotation")
                 assertThat(symbols.size).isEqualTo(1)
@@ -92,7 +88,7 @@ class KspTest {
         }
         val result = KotlinCompilation().apply {
             sources = listOf(annotation, targetClass)
-            symbolProcessors(processorRule.delegateTo(processor))
+            symbolProcessors = listOf(processor)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
@@ -111,25 +107,48 @@ class KspTest {
         )
         val result = KotlinCompilation().apply {
             sources = listOf(source)
-            symbolProcessors(Write_foo_bar_A::class.java, Write_foo_bar_B::class.java)
-            symbolProcessors(Write_foo_bar_C::class.java)
+            symbolProcessors = listOf(
+                ClassGeneratingProcessor("generated", "A"),
+                ClassGeneratingProcessor("generated", "B"))
+            symbolProcessors = symbolProcessors + ClassGeneratingProcessor("generated", "C")
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
 
-    @Suppress("ClassName")
-    internal class Write_foo_bar_A() : ClassGeneratingProcessor("generated", "A")
-
-    @Suppress("ClassName")
-    internal class Write_foo_bar_B() : ClassGeneratingProcessor("generated", "B")
+    @Test
+    fun readProcessors() {
+        val instance1 = mock<SymbolProcessor>()
+        val instance2 = mock<SymbolProcessor>()
+        KotlinCompilation().apply {
+            symbolProcessors = listOf(instance1)
+            assertThat(symbolProcessors).containsExactly(instance1)
+            symbolProcessors = listOf(instance2)
+            assertThat(symbolProcessors).containsExactly(instance2)
+            symbolProcessors = symbolProcessors + instance1
+            assertThat(symbolProcessors).containsExactly(instance2, instance1)
+        }
+    }
 
-    @Suppress("ClassName")
-    internal class Write_foo_bar_C() : ClassGeneratingProcessor("generated", "C")
+    @Test
+    fun outputDirectoryContents() {
+        val compilation = KotlinCompilation().apply {
+            sources = listOf(DUMMY_KOTLIN_SRC)
+            symbolProcessors = listOf(ClassGeneratingProcessor("generated", "Gen"))
+        }
+        val result = compilation.compile()
+        assertThat(result.exitCode).isEqualTo(ExitCode.OK)
+        val generatedSources = compilation.kspSourcesDir.walkTopDown().filter {
+            it.isFile
+        }.toList()
+        assertThat(generatedSources).containsExactly(
+            compilation.kspSourcesDir.resolve("generated/Gen.kt")
+        )
+    }
 
     internal open class ClassGeneratingProcessor(
         private val packageName: String,
         private val className: String
-    ) : AbstractSymbolProcessor() {
+    ) : AbstractTestSymbolProcessor() {
         override fun process(resolver: Resolver) {
             super.process(resolver)
             codeGenerator.createNewFile(packageName, className).writeText(