Update KSP to alpha08 and adopt new ProcessorProvider API

KSP alpha08 introduces a new `SymbolProcessorProvider` API to allow for creating immutable/stateless processors. This updates the KSP APIs to this new pattern, as the old `init()`-based pattern is deprecated and will eventually be removed.

Author: ZacSweers

ksp/build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.ksp_version='1.4.32-1.0.0-alpha07'
+    ext.ksp_version='1.4.32-1.0.0-alpha08'
 }
 
 dependencies {

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

@@ -6,7 +6,7 @@ package com.tschuchort.compiletesting
 import com.google.devtools.ksp.AbstractKotlinSymbolProcessingExtension
 import com.google.devtools.ksp.KspOptions
 import com.google.devtools.ksp.processing.KSPLogger
-import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
 import com.google.devtools.ksp.processing.impl.MessageCollectorBasedKSPLogger
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
@@ -23,11 +23,11 @@ import java.io.File
  * The list of symbol processors for the kotlin compilation.
  * https://goo.gle/ksp
  */
-var KotlinCompilation.symbolProcessors: List<SymbolProcessor>
-    get() = getKspRegistrar().processors
+var KotlinCompilation.symbolProcessorProviders: List<SymbolProcessorProvider>
+    get() = getKspRegistrar().providers
     set(value) {
         val registrar = getKspRegistrar()
-        registrar.processors = value
+        registrar.providers = value
     }
 
 /**
@@ -102,16 +102,16 @@ private val KotlinCompilation.kspCachesDir: File
  */
 private class KspTestExtension(
     options: KspOptions,
-    processors: List<SymbolProcessor>,
+    processorProviders: List<SymbolProcessorProvider>,
     logger: KSPLogger
 ) : AbstractKotlinSymbolProcessingExtension(
     options = options,
     logger = logger,
     testMode = false
 ) {
-    private val loadedProcessors = processors
+    private val loadedProviders = processorProviders
 
-    override fun loadProcessors() = loadedProcessors
+    override fun loadProviders() = loadedProviders
 }
 
 /**
@@ -120,15 +120,15 @@ private class KspTestExtension(
 private class KspCompileTestingComponentRegistrar(
     private val compilation: KotlinCompilation
 ) : ComponentRegistrar {
-    var processors = emptyList<SymbolProcessor>()
+    var providers = emptyList<SymbolProcessorProvider>()
 
     var options: MutableMap<String, String> = mutableMapOf()
 
     var incremental: Boolean = false
     var incrementalLog: Boolean = false
 
     override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        if (processors.isEmpty()) {
+        if (providers.isEmpty()) {
             return
         }
         val options = KspOptions.Builder().apply {
@@ -180,7 +180,7 @@ private class KspCompileTestingComponentRegistrar(
                 compilation.verbose
             )
         )
-        val registrar = KspTestExtension(options, processors, messageCollectorBasedKSPLogger)
+        val registrar = KspTestExtension(options, providers, messageCollectorBasedKSPLogger)
         AnalysisHandlerExtension.registerExtension(project, registrar)
     }
 }

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

@@ -1,24 +1,36 @@
 package com.tschuchort.compiletesting
 
-import com.google.devtools.ksp.processing.CodeGenerator
-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.processing.*
 import com.google.devtools.ksp.symbol.KSAnnotated
 
 /**
  * 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
-    protected lateinit var logger: KSPLogger
-
-    override fun init(options: Map<String, String>, kotlinVersion: KotlinVersion, codeGenerator: CodeGenerator, logger: KSPLogger) {
-        this.codeGenerator = codeGenerator
-        this.logger = logger
-    }
-
+internal open class AbstractTestSymbolProcessor(
+    protected val codeGenerator: CodeGenerator
+) : SymbolProcessor {
     override fun process(resolver: Resolver): List<KSAnnotated> {
         return emptyList()
     }
 }
+
+// Would be nice if SymbolProcessorProvider was a fun interface
+internal fun processorProviderOf(
+    body: (
+        options: Map<String, String>,
+        kotlinVersion: KotlinVersion,
+        codeGenerator: CodeGenerator,
+        logger: KSPLogger
+    ) -> SymbolProcessor
+): SymbolProcessorProvider {
+    return object : SymbolProcessorProvider {
+        override fun create(
+            options: Map<String, String>,
+            kotlinVersion: KotlinVersion,
+            codeGenerator: CodeGenerator,
+            logger: KSPLogger
+        ): SymbolProcessor {
+            return body(options, kotlinVersion, codeGenerator, logger)
+        }
+    }
+}

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

@@ -1,8 +1,6 @@
 package com.tschuchort.compiletesting
 
-import com.google.devtools.ksp.processing.Dependencies
-import com.google.devtools.ksp.processing.Resolver
-import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.*
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.nhaarman.mockitokotlin2.any
@@ -21,12 +19,14 @@ class KspTest {
     @Test
     fun failedKspTest() {
         val instance = mock<SymbolProcessor>()
+        val providerInstance = mock<SymbolProcessorProvider>()
+        `when`(providerInstance.create(any(), any(), any(), any())).thenReturn(instance)
         `when`(instance.process(any())).thenThrow(
             RuntimeException("intentional fail")
         )
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessors = listOf(instance)
+            symbolProcessorProviders = listOf(providerInstance)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.INTERNAL_ERROR)
         assertThat(result.messages).contains("intentional fail")
@@ -35,13 +35,17 @@ class KspTest {
     @Test
     fun allProcessorMethodsAreCalled() {
         val instance = mock<SymbolProcessor>()
+        val providerInstance = mock<SymbolProcessorProvider>()
+        `when`(providerInstance.create(any(), any(), any(), any())).thenReturn(instance)
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessors = listOf(instance)
+            symbolProcessorProviders = listOf(providerInstance)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
+        providerInstance.inOrder {
+            verify().create(any(), any(), any(), any())
+        }
         instance.inOrder {
-            verify().init(any(), any(), any(), any())
             verify().process(any())
             verify().finish()
         }
@@ -68,33 +72,34 @@ class KspTest {
             }
         """.trimIndent()
         )
-        val processor = object : AbstractTestSymbolProcessor() {
-            override fun process(resolver: Resolver): List<KSAnnotated> {
-                val symbols = resolver.getSymbolsWithAnnotation("foo.bar.TestAnnotation")
-                if (symbols.isNotEmpty())  {
-                    assertThat(symbols.size).isEqualTo(1)
-                    val klass = symbols.first()
-                    check(klass is KSClassDeclaration)
-                    val qName = klass.qualifiedName ?: error("should've found qualified name")
-                    val genPackage = "${qName.getQualifier()}.generated"
-                    val genClassName = "${qName.getShortName()}_Gen"
-                    codeGenerator.createNewFile(
-                        dependencies = Dependencies.ALL_FILES,
-                        packageName = genPackage,
-                        fileName = genClassName
-                    ).bufferedWriter(Charsets.UTF_8).use {
-                        it.write("""
+        val result = KotlinCompilation().apply {
+            sources = listOf(annotation, targetClass)
+            symbolProcessorProviders = listOf(processorProviderOf { _, _, codeGenerator, logger ->
+                object : AbstractTestSymbolProcessor(codeGenerator) {
+                    override fun process(resolver: Resolver): List<KSAnnotated> {
+                        val symbols = resolver.getSymbolsWithAnnotation("foo.bar.TestAnnotation")
+                        if (symbols.isNotEmpty())  {
+                            assertThat(symbols.size).isEqualTo(1)
+                            val klass = symbols.first()
+                            check(klass is KSClassDeclaration)
+                            val qName = klass.qualifiedName ?: error("should've found qualified name")
+                            val genPackage = "${qName.getQualifier()}.generated"
+                            val genClassName = "${qName.getShortName()}_Gen"
+                            codeGenerator.createNewFile(
+                                dependencies = Dependencies.ALL_FILES,
+                                packageName = genPackage,
+                                fileName = genClassName
+                            ).bufferedWriter(Charsets.UTF_8).use {
+                                it.write("""
                             package $genPackage
                             class $genClassName() {}
                         """.trimIndent())
+                            }
+                        }
+                        return emptyList()
                     }
                 }
-                return emptyList()
-            }
-        }
-        val result = KotlinCompilation().apply {
-            sources = listOf(annotation, targetClass)
-            symbolProcessors = listOf(processor)
+            })
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
@@ -113,25 +118,26 @@ class KspTest {
         )
         val result = KotlinCompilation().apply {
             sources = listOf(source)
-            symbolProcessors = listOf(
-                ClassGeneratingProcessor("generated", "A"),
-                ClassGeneratingProcessor("generated", "B"))
-            symbolProcessors = symbolProcessors + ClassGeneratingProcessor("generated", "C")
+            symbolProcessorProviders = listOf(
+                processorProviderOf { _, _, codeGenerator, logger -> ClassGeneratingProcessor(codeGenerator, "generated", "A") },
+                processorProviderOf { _, _, codeGenerator, logger -> ClassGeneratingProcessor(codeGenerator, "generated", "B") })
+            symbolProcessorProviders = symbolProcessorProviders +
+                    processorProviderOf { _, _, codeGenerator, logger -> ClassGeneratingProcessor(codeGenerator, "generated", "C") }
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
 
     @Test
     fun readProcessors() {
-        val instance1 = mock<SymbolProcessor>()
-        val instance2 = mock<SymbolProcessor>()
+        val instance1 = mock<SymbolProcessorProvider>()
+        val instance2 = mock<SymbolProcessorProvider>()
         KotlinCompilation().apply {
-            symbolProcessors = listOf(instance1)
-            assertThat(symbolProcessors).containsExactly(instance1)
-            symbolProcessors = listOf(instance2)
-            assertThat(symbolProcessors).containsExactly(instance2)
-            symbolProcessors = symbolProcessors + instance1
-            assertThat(symbolProcessors).containsExactly(instance2, instance1)
+            symbolProcessorProviders = listOf(instance1)
+            assertThat(symbolProcessorProviders).containsExactly(instance1)
+            symbolProcessorProviders = listOf(instance2)
+            assertThat(symbolProcessorProviders).containsExactly(instance2)
+            symbolProcessorProviders = symbolProcessorProviders + instance1
+            assertThat(symbolProcessorProviders).containsExactly(instance2, instance1)
         }
     }
 
@@ -152,7 +158,9 @@ class KspTest {
     fun outputDirectoryContents() {
         val compilation = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessors = listOf(ClassGeneratingProcessor("generated", "Gen"))
+            symbolProcessorProviders = listOf(processorProviderOf { _, _, codeGenerator, logger ->
+                ClassGeneratingProcessor(codeGenerator, "generated", "Gen")
+            })
         }
         val result = compilation.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
@@ -181,32 +189,34 @@ class KspTest {
             """.trimIndent()
         )
         val result = mutableListOf<String>()
-        val processor = object : AbstractTestSymbolProcessor() {
-            override fun process(resolver: Resolver): List<KSAnnotated> {
-                resolver.getSymbolsWithAnnotation(
-                    SuppressWarnings::class.java.canonicalName
-                ).filterIsInstance<KSClassDeclaration>()
-                    .forEach {
-                        result.add(it.qualifiedName!!.asString())
-                    }
-                return emptyList()
-            }
-        }
         val compilation = KotlinCompilation().apply {
             sources = listOf(javaSource, kotlinSource)
-            symbolProcessors += processor
+            symbolProcessorProviders += processorProviderOf { _, _, codeGenerator, logger ->
+                object : AbstractTestSymbolProcessor(codeGenerator) {
+                    override fun process(resolver: Resolver): List<KSAnnotated> {
+                        resolver.getSymbolsWithAnnotation(
+                            SuppressWarnings::class.java.canonicalName
+                        ).filterIsInstance<KSClassDeclaration>()
+                            .forEach {
+                                result.add(it.qualifiedName!!.asString())
+                            }
+                        return emptyList()
+                    }
+                }
+            }
         }
         compilation.compile()
         assertThat(result).containsExactlyInAnyOrder(
             "JavaSubject", "KotlinSubject"
         )
     }
 
-    internal open class ClassGeneratingProcessor(
+    internal class ClassGeneratingProcessor(
+        codeGenerator: CodeGenerator,
         private val packageName: String,
         private val className: String,
         times: Int = 1
-    ) : AbstractTestSymbolProcessor() {
+    ) : AbstractTestSymbolProcessor(codeGenerator) {
         val times = AtomicInteger(times)
         override fun process(resolver: Resolver): List<KSAnnotated> {
             super.process(resolver)
@@ -241,17 +251,18 @@ class KspTest {
             class AppCode
         """.trimIndent()
         )
-        val processor = object : AbstractTestSymbolProcessor() {
-            override fun process(resolver: Resolver): List<KSAnnotated> {
-                logger.logging("This is a log message")
-                logger.info("This is an info message")
-                logger.warn("This is an warn message")
-                return emptyList()
-            }
-        }
         val result = KotlinCompilation().apply {
             sources = listOf(annotation, targetClass)
-            symbolProcessors = listOf(processor)
+            symbolProcessorProviders = listOf(processorProviderOf { _, _, codeGenerator, logger ->
+                object : AbstractTestSymbolProcessor(codeGenerator) {
+                    override fun process(resolver: Resolver): List<KSAnnotated> {
+                        logger.logging("This is a log message")
+                        logger.info("This is an info message")
+                        logger.warn("This is an warn message")
+                        return emptyList()
+                    }
+                }
+            })
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
         assertThat(result.messages).contains("This is a log message")
@@ -274,16 +285,17 @@ class KspTest {
             class AppCode
         """.trimIndent()
         )
-        val processor = object : AbstractTestSymbolProcessor() {
-            override fun process(resolver: Resolver): List<KSAnnotated> {
-                logger.error("This is an error message")
-                logger.exception(Throwable("This is a failure"))
-                return emptyList()
-            }
-        }
         val result = KotlinCompilation().apply {
             sources = listOf(annotation, targetClass)
-            symbolProcessors = listOf(processor)
+            symbolProcessorProviders = listOf(processorProviderOf { _, _, codeGenerator, logger ->
+                object : AbstractTestSymbolProcessor(codeGenerator) {
+                    override fun process(resolver: Resolver): List<KSAnnotated> {
+                        logger.error("This is an error message")
+                        logger.exception(Throwable("This is a failure"))
+                        return emptyList()
+                    }
+                }
+            })
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.COMPILATION_ERROR)
         assertThat(result.messages).contains("This is an error message")