Test that java annotation processors are run

tschuchortdev · tschuchortdev · commit 66feb61145cd · 2019-01-03T23:46:10.000+01:00
diff --git a/build.gradle b/build.gradle
@@ -14,7 +14,6 @@ buildscript {
 plugins {
     id 'java'
     id 'org.jetbrains.kotlin.jvm' version '1.3.11'
-
 }
 
 apply plugin: 'kotlin'
diff --git a/src/test/java/JavaTestProcessor.java b/src/test/java/JavaTestProcessor.java
@@ -0,0 +1,84 @@
+import com.squareup.kotlinpoet.FileSpec;
+import com.squareup.kotlinpoet.FunSpec;
+import com.squareup.kotlinpoet.TypeSpec;
+import kotlin.text.Charsets;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class JavaTestProcessor extends AbstractProcessor {
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+         LinkedHashSet<String> set = new LinkedHashSet<>();
+         set.add(Marker.class.getCanonicalName());
+         return set;
+    }
+
+    @Override
+    public Set<String> getSupportedOptions() {
+        LinkedHashSet<String> set = new LinkedHashSet<>();
+        set.add("kapt.kotlin.generated");
+        return set;
+    }
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "java processor init");
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "java processor was called");
+
+        if(!annotations.isEmpty()) {
+            TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder("JavaGeneratedKotlinClass");
+
+            for(Element annotatedElement : roundEnv.getElementsAnnotatedWith(Marker.class)) {
+                typeSpecBuilder.addFunction(FunSpec.builder(annotatedElement.getSimpleName().toString()
+                        ).build()
+                ).build();
+            }
+
+            FileSpec fileSpec = FileSpec.builder("", "JavaGeneratedKotlinClass.kt")
+                    .addType(typeSpecBuilder.build())
+                    .build();
+
+            writeKotlinFile(fileSpec, fileSpec.getName(), fileSpec.getPackageName());
+        }
+
+        return false;
+    }
+
+    private void writeKotlinFile(FileSpec fileSpec, String fileName, String packageName) {
+        String kaptKotlinGeneratedDir = processingEnv.getOptions().get("kapt.kotlin.generated");
+
+        String relativePath = packageName.replace('.', File.separatorChar);
+
+        File outputFolder = new File(kaptKotlinGeneratedDir, relativePath);
+        outputFolder.mkdirs();
+
+        // finally write to output file
+        try {
+            (new FileOutputStream(new File(outputFolder, fileName))).write(fileSpec.toString().getBytes(Charsets.UTF_8));
+        }
+        catch(Exception e) {
+
+        }
+    }
+}
diff --git a/src/test/kotlin/JavacUtils.kt b/src/test/kotlin/JavacUtils.kt
@@ -1,9 +1,5 @@
-package com.tschuchort.compiletest
-
-import org.jetbrains.kotlin.incremental.isJavaFile
 import java.io.*
 import java.net.URI
-import java.net.URL
 import java.nio.charset.Charset
 import javax.tools.JavaCompiler
 import javax.tools.JavaFileObject
diff --git a/src/test/kotlin/KotlinCompilation.kt b/src/test/kotlin/KotlinCompilation.kt
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.tschuchort.compiletest
 
+import com.tschuchort.compiletest.NullStream
+import com.tschuchort.compiletest.TeeOutputStream
 import io.github.classgraph.ClassGraph
 import okio.Buffer
 import okio.buffer
@@ -65,39 +66,39 @@ open class KotlinCompilation(
 	 * process' classpaths
 	 */
 	val kotlinStdLibJar: File? = findKtStdLib(
-		log = { if(verbose) systemOut.log(it) }
+		log = { if (verbose) systemOut.log(it) }
 	),
 	/**
 	 * Path to the kotlin-stdlib-jdk*.jar
 	 * If none is given, it will be searched for in the host
 	 * process' classpaths
 	 */
 	val kotlinStdLibJdkJar: File? = findKtStdLibJdk(
-		log = { if(verbose) systemOut.log(it) }
+		log = { if (verbose) systemOut.log(it) }
 	),
 	/**
 	 * Path to the kotlin-reflect.jar
 	 * If none is given, it will be searched for in the host
 	 * process' classpaths
 	 */
 	val kotlinReflectJar: File? = findKtReflect(
-		log = { if(verbose) systemOut.log(it) }
+		log = { if (verbose) systemOut.log(it) }
 	),
 	/**
 	 * Path to the kotlin-script-runtime.jar
 	 * If none is given, it will be searched for in the host
 	 * process' classpaths
 	 */
 	val kotlinScriptRuntimeJar: File? = findKtScriptRt(
-		log = { if(verbose) systemOut.log(it) }
+		log = { if (verbose) systemOut.log(it) }
 	),
 	/**
 	 * Path to the kotlin-stdlib-common.jar
 	 * If none is given, it will be searched for in the host
 	 * process' classpaths
 	 */
 	val kotlinStdLibCommonJar: File? = findKtStdLibCommon(
-		log = { if(verbose) systemOut.log(it) }
+		log = { if (verbose) systemOut.log(it) }
 	),
 	/**
 	 * Path to the tools.jar file needed for kapt when using a JDK 8.
@@ -106,17 +107,17 @@ open class KotlinCompilation(
 	 * internal compiler error!
 	 */
 	val toolsJar: File? = findToolsInHostClasspath(
-        log = { if(verbose) systemOut.log(it) }
-    ),
+		log = { if (verbose) systemOut.log(it) }
+	),
 	/**
      * Path to the kotlin-annotation-processing-embeddable*.jar that
      * contains kapt3.
      *
      * Only needed when [services] is not empty.
      */
     val kapt3Jar: File? = findKapt3(
-		log = { if(verbose) systemOut.log(it) }
-    ),
+		log = { if (verbose) systemOut.log(it) }
+	),
 	/** Inherit classpath from calling process */
 	val inheritClassPath: Boolean = false,
 	val jvmTarget: String? = null,
@@ -272,6 +273,7 @@ open class KotlinCompilation(
 			// Don't forget aptMode! Without it, the compiler will crash with an obscure error about
 			// write unsafe context
 			"plugin:org.jetbrains.kotlin.kapt3:aptMode=stubsAndApt",
+			"plugin:org.jetbrains.kotlin.kapt3:mapDiagnosticLocations=true",
 			*if (verbose)
 				arrayOf("plugin:org.jetbrains.kotlin.kapt3:verbose=true")
 			else
@@ -370,7 +372,8 @@ open class KotlinCompilation(
 		val compilerSystemOutBuffer = Buffer()  // Buffer for capturing compiler's logging output
 		val compilerMessageCollector = PrintingMessageCollector(
 			PrintStream(
-				TeeOutputStream(systemOut, compilerSystemOutBuffer.outputStream())),
+				TeeOutputStream(systemOut, compilerSystemOutBuffer.outputStream())
+			),
 			MessageRenderer.WITHOUT_PATHS, true)
 
 		/*
@@ -462,34 +465,46 @@ open class KotlinCompilation(
 
 		/** Tries to find the kotlin-stdlib.jar in the host process' classpath */
 		fun findKtStdLib(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-stdlib.jar",
-			Regex("(kotlin-stdlib|kotlin-runtime)(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-stdlib.jar",
+			Regex("(kotlin-stdlib|kotlin-runtime)(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log
+		)
 			// kotlin-stdlib.jar used to be kotlin-runtime.jar in <1.1
 
 		/** Tries to find the kotlin-stdlib-jdk*.jar in the host process' classpath */
 		fun findKtStdLibJdk(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-stdlib-jdk*.jar",
-			Regex("kotlin-stdlib-jdk[0-9]+(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-stdlib-jdk*.jar",
+			Regex("kotlin-stdlib-jdk[0-9]+(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log
+		)
 
 		/** Tries to find the kotlin-stdlib-common.jar in the host process' classpath */
 		fun findKtStdLibCommon(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-stdlib-common.jar",
-			Regex("kotlin-stdlib-common(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-stdlib-common.jar",
+			Regex("kotlin-stdlib-common(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log
+		)
 
 		/** Tries to find the kotlin-reflect.jar in the host process' classpath */
 		fun findKtReflect(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-reflect.jar",
-			Regex("kotlin-reflect(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-reflect.jar",
+			Regex("kotlin-reflect(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log
+		)
 
 		/** Tries to find the kotlin-script-runtime.jar in the host process' classpath */
 		fun findKtScriptRt(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-script-runtime.jar",
-			Regex("kotlin-script-runtime(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-script-runtime.jar",
+			Regex("kotlin-script-runtime(-[0-9]+\\.[0-9]+\\.[0-9]+)\\.jar"), log
+		)
 
         /** Tries to find the kapt 3 jar in the host process' classpath */
         fun findKapt3(log: ((String) -> Unit)? = null)
-				= findInHostClasspath("kotlin-annotation-processing(-embeddable).jar",
-			Regex("kotlin-annotation-processing(-(embeddable|gradle|maven))?(-[0-9]+\\.[0-9]+\\.[0-9]+)?\\.jar"), log)
+				= findInHostClasspath(
+			"kotlin-annotation-processing(-embeddable).jar",
+			Regex("kotlin-annotation-processing(-(embeddable|gradle|maven))?(-[0-9]+\\.[0-9]+\\.[0-9]+)?\\.jar"), log
+		)
 
 
         /** Tries to find the tools.jar needed for kapt in the host process' classpath */
diff --git a/src/test/kotlin/KotlinTestProcessor.kt b/src/test/kotlin/KotlinTestProcessor.kt
@@ -1,5 +1,3 @@
-package com.tschuchort.compiletest
-
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.TypeSpec
@@ -11,7 +9,7 @@ import javax.tools.Diagnostic
 
 annotation class Marker
 
-class TestProcessor : AbstractProcessor() {
+class KotlinTestProcessor : AbstractProcessor() {
 	companion object {
 		const val KAPT_KOTLIN_GENERATED_OPTION_NAME = "kapt.kotlin.generated"
 		const val GENERATE_KOTLIN_CODE_OPTION = "generate.kotlin.code"
@@ -25,7 +23,11 @@ class TestProcessor : AbstractProcessor() {
 	private val generatedFilesSuffix by lazy { processingEnv.options[FILE_SUFFIX_OPTION] ?: "Generated"}
 
 	override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latest()
-	override fun getSupportedOptions() = setOf(KAPT_KOTLIN_GENERATED_OPTION_NAME, GENERATE_KOTLIN_CODE_OPTION, GENERATE_ERRORS_OPTION)
+	override fun getSupportedOptions() = setOf(
+		KAPT_KOTLIN_GENERATED_OPTION_NAME,
+		GENERATE_KOTLIN_CODE_OPTION,
+		GENERATE_ERRORS_OPTION
+	)
 	override fun getSupportedAnnotationTypes(): Set<String> = setOf(Marker::class.java.canonicalName)
 
     override fun init(processingEnv: ProcessingEnvironment) {
@@ -34,20 +36,21 @@ class TestProcessor : AbstractProcessor() {
     }
 
 	override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
-		for(annotatedElem in roundEnv.getElementsAnnotatedWith(Marker::class.java)) {
-			val fileSpec = FileSpec.builder("com.tschuchort.compiletest", "GeneratedClass.kt")
-				.addType(TypeSpec.classBuilder("GeneratedClass")
-					.addFunction(FunSpec.builder(annotatedElem.simpleName.toString())
-						.build()
-					).build()
-				).build()
+		processingEnv.messager.printMessage(Diagnostic.Kind.WARNING, "kotlin processor was called")
 
-			writeKotlinFile(fileSpec)
-		}
-
-        processingEnv.messager.printMessage(Diagnostic.Kind.WARNING, "kotlin processor was called")
+		if(annotations.isNotEmpty())
+			FileSpec.builder("", "KotlinGeneratedKotlinClass.kt")
+				.addType(TypeSpec.classBuilder("KotlinGeneratedKotlinClass").apply {
+						for(annotatedElem in roundEnv.getElementsAnnotatedWith(Marker::class.java)) {
+							addFunction(FunSpec.builder(annotatedElem.simpleName.toString())
+								.build()
+							)
+						}
+					}.build()
+				).build()
+				.let { writeKotlinFile(it) }
 
-		return true
+		return false
 	}
 
 	private fun writeKotlinFile(fileSpec: FileSpec, fileName: String = fileSpec.name, packageName: String = fileSpec.packageName) {
diff --git a/src/test/kotlin/SmokeTests.kt b/src/test/kotlin/SmokeTests.kt
@@ -1,5 +1,3 @@
-package com.tschuchort.compiletest
-
 import okio.Buffer
 import org.assertj.core.api.Assertions.assertThat
 import org.jetbrains.kotlin.cli.common.ExitCode
@@ -15,11 +13,13 @@ class SmokeTests {
 
 	@Test
 	fun `compilation succeeds`() {
-		val kSource = KotlinCompilation.SourceFile("kSource.kt",
-				"""import com.tschuchort.compiletest.Marker
+		val kSource = KotlinCompilation.SourceFile(
+			"kSource.kt",
+			"""//import Marker
 					import javax.lang.model.SourceVersion
 					import java.io.File
-					import com.tschuchort.compiletest.GeneratedClass
+					//import com.tschuchort.compiletest.KotlinGeneratedKotlinClass
+					//import com.tschuchort.compiletest.JavaGeneratedKotlinClass
 
 					class KotClass {
 						fun brr() {}
@@ -33,27 +33,44 @@ class SmokeTests {
 					fun main(freeArgs: Array<String>) {
 						File("")
 						println("hello")
-						GeneratedClass().foo()
+						KotlinGeneratedKotlinClass().foo()
+						KotlinGeneratedKotlinClass().bar()
+						JavaGeneratedKotlinClass().foo()
+						JavaGeneratedKotlinClass().bar()
 					}
 				""".trimIndent()
 		)
 
-		val jSource = KotlinCompilation.SourceFile("JSource.java",
-				"""
-    			import com.tschuchort.compiletest.Marker;
+		val jSource = KotlinCompilation.SourceFile(
+			"JSource.java",
+			"""
+                //import com.tschuchort.compiletest.KotlinGeneratedKotlinClass;
+                //import com.tschuchort.compiletest.JavaGeneratedKotlinClass;
+
     			public class JSource {
+                    public JSource() {
+                        (new KotlinGeneratedKotlinClass()).foo();
+						(new KotlinGeneratedKotlinClass()).bar();
+						(new JavaGeneratedKotlinClass()).foo();
+						(new JavaGeneratedKotlinClass()).bar();
+                    }
+
     				@Marker public void bar() {
     					(new KotClass()).brr();
     				}
                 }
-				""".trimIndent())
+				""".trimIndent()
+		)
 
 		val systemOutBuffer = Buffer()
 
 		val result = KotlinCompilation(
 			workingDir = File("C:\\compile-testing"),
 			sources = listOf(kSource, jSource),
-			services = listOf(KotlinCompilation.Service(Processor::class, TestProcessor::class)),
+			services = listOf(
+				KotlinCompilation.Service(Processor::class, KotlinTestProcessor::class),
+				KotlinCompilation.Service(Processor::class, JavaTestProcessor::class)
+			),
 			jdkHome = File("D:\\Program Files\\Java\\jdk1.8.0_25"),//getJavaHome(),
 			//toolsJar = File("D:\\Program Files\\Java\\jdk1.8.0_25\\lib\\tools.jar"),
 			inheritClassPath = true,
diff --git a/src/test/kotlin/StreamUtilTests.kt b/src/test/kotlin/StreamUtilTests.kt

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ buildscript {`
`14`	`14`	`plugins {`
`15`	`15`	`id 'java'`
`16`	`16`	`id 'org.jetbrains.kotlin.jvm' version '1.3.11'`
`17`		`-`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`apply plugin: 'kotlin'`