create new module for ksp support

Fixes

Author: yigit

.gitignore

@@ -233,3 +233,4 @@ hs_err_pid*
 
 !gradle/wrapper/gradle-wrapper.jar
 
+ksp/build

build.gradle

@@ -1,9 +1,10 @@
 buildscript {
-    ext.kotlin_version = '1.3.72'
+    ext.kotlin_version = '1.4-M1'
 
     repositories {
         mavenCentral()
         maven { url 'https://jitpack.io' }
+        maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
     }
 
     dependencies {
@@ -15,7 +16,6 @@ buildscript {
 
 plugins {
     id 'java'
-    id 'org.jetbrains.kotlin.jvm' version "$kotlin_version"
     id "com.github.gmazzo.buildconfig" version "2.0.1"
 }
 
@@ -32,6 +32,7 @@ repositories {
     maven { url 'https://jitpack.io' }
     maven { url 'https://kotlin.bintray.com/kotlinx' }
     jcenter()
+    maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
 }
 
 idea {

ksp/build.gradle

@@ -0,0 +1,30 @@
+apply plugin: 'kotlin'
+// TODO remove group and version
+group 'com.github.tschuchortdev'
+version '1.2.8'
+ext.ksp_version='1.4-M1-dev-experimental-20200610'
+
+repositories {
+    maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    api(rootProject)
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    implementation "org.jetbrains.kotlin:kotlin-symbol-processing-api:$ksp_version"
+    implementation "org.jetbrains.kotlin:kotlin-ksp:$ksp_version"
+    implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:$kotlin_version"
+
+    testImplementation group: 'junit', name: 'junit', version: '4.12'
+    testImplementation "org.assertj:assertj-core:3.11.1"
+    testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:2.2.0"
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Adds support for KSP (https://goo.gle/ksp).
+ */
+package com.tschuchort.compiletesting
+
+import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingCommandLineProcessor
+import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingComponentRegistrar
+import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
+
+private const val KSP_PLUGIN_ID = "org.jetbrains.kotlin.ksp"
+
+// TODO can we add support for instances?
+fun KotlinCompilation.symbolProcessor(
+    vararg processors : Class<out SymbolProcessor>
+) {
+    check(processors.isNotEmpty()) {
+        "Must provide at least 1 symbol processor"
+    }
+    val kspWorkingDir = workingDir.resolve("ksp")
+
+    // create a fake classpath that references our symbol processor
+    val processorClasspath = kspWorkingDir.resolve("synthetic-ksp-service").apply {
+        resolve("META-INF/services/org.jetbrains.kotlin.ksp.processing.SymbolProcessor").apply {
+            parentFile.mkdirs()
+            val processorNames = processors.joinToString(System.lineSeparator()) {
+                it.typeName
+            }
+            writeText(
+                processorNames
+            )
+        }
+    }
+
+    val classesFolder = kspWorkingDir.resolve("outClasses").also {
+        it.mkdirs()
+    }
+    val sourceFolder = kspWorkingDir.resolve("outSources").also {
+        it.mkdirs()
+    }
+    val kspOptions = listOf(
+        PluginOption(KSP_PLUGIN_ID, "apclasspath", processorClasspath.path),
+        PluginOption(KSP_PLUGIN_ID, "classes", classesFolder.path),
+        PluginOption(KSP_PLUGIN_ID, "sources", sourceFolder.path)
+    )
+    compilerPlugins += KotlinSymbolProcessingComponentRegistrar()
+    commandLineProcessors += listOf(KotlinSymbolProcessingCommandLineProcessor())
+    pluginOptions += kspOptions
+    this.kaptSourceDir
+}

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

@@ -0,0 +1,16 @@
+package com.tschuchort.compiletesting
+
+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 {
+    override fun finish() {
+    }
+
+    override fun init(options: Map<String, String>, kotlinVersion: KotlinVersion, codeGenerator: CodeGenerator) {
+    }
+
+    override fun process(resolver: Resolver) {
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.tschuchort.compiletesting
+
+import org.jetbrains.kotlin.ksp.processing.CodeGenerator
+import org.jetbrains.kotlin.ksp.processing.Resolver
+import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
+import org.junit.rules.TestWatcher
+import org.junit.runner.Description
+
+internal class DelegateProcessor : SymbolProcessor {
+    private val delegate
+        get() = checkNotNull(Companion.delegate) {
+            "Delegate is not provided"
+        }
+
+    override fun finish() {
+        delegate.finish()
+    }
+
+    override fun init(options: Map<String, String>, kotlinVersion: KotlinVersion, codeGenerator: CodeGenerator) {
+        delegate.init(
+            options = options,
+            kotlinVersion = kotlinVersion,
+            codeGenerator = codeGenerator
+        )
+    }
+
+    override fun process(resolver: Resolver) {
+        delegate.process(resolver)
+    }
+
+    companion object {
+        var delegate: SymbolProcessor? = null
+    }
+}
+
+class DelegatingSymbolProcessorRule : TestWatcher() {
+    fun delegateTo(processor: SymbolProcessor): Class<out SymbolProcessor> {
+        check(DelegateProcessor.delegate == null) {
+            "Cannot use DelegatingSymbolProcessorRule more than once"
+        }
+        DelegateProcessor.delegate = processor
+        return DelegateProcessor::class.java
+    }
+
+    override fun finished(description: Description?) {
+        DelegateProcessor.delegate = null
+        super.finished(description)
+    }
+}

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

@@ -0,0 +1,58 @@
+package com.tschuchort.compiletesting
+
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.inOrder
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import com.tschuchort.compiletesting.KotlinCompilation.ExitCode
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.kotlin.ksp.processing.Resolver
+import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class KspTest {
+    @Rule
+    @JvmField
+    val processorRule = DelegatingSymbolProcessorRule()
+
+    @Test
+    fun failedKspTest() {
+        val result = KotlinCompilation().apply {
+            sources = listOf(DUMMY_KOTLIN_SRC)
+            symbolProcessor(processorRule.delegateTo(object : AbstractSymbolProcessor() {
+                override fun process(resolver: Resolver) {
+                    throw RuntimeException("intentional fail")
+                }
+            }))
+        }.compile()
+        assertThat(result.exitCode).isEqualTo(ExitCode.INTERNAL_ERROR)
+        assertThat(result.messages).contains("intentional fail")
+    }
+
+    @Test
+    fun processorIsCalled() {
+        val instance = mock<SymbolProcessor>()
+        val result = KotlinCompilation().apply {
+            sources = listOf(DUMMY_KOTLIN_SRC)
+            symbolProcessor(processorRule.delegateTo(instance))
+        }.compile()
+        assertThat(result.exitCode).isEqualTo(ExitCode.OK)
+        instance.inOrder {
+            verify().init(any(), any(), any())
+            verify().process(any())
+            verify().finish()
+        }
+    }
+
+    companion object {
+        private val DUMMY_KOTLIN_SRC = SourceFile.kotlin(
+            "foo.bar.Dummy.kt", """
+            class Dummy {}
+        """.trimIndent()
+        )
+    }
+}

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

@@ -0,0 +1,2 @@
+package com.tschuchort.compiletesting
+

settings.gradle

@@ -1,2 +1,3 @@
 rootProject.name = 'kotlin-compile-testing'
+include("ksp")