Add more tests for AP, fix kapt crashing when no Kotlin sources are given

Author: tschuchortdev

build.gradle

@@ -49,6 +49,7 @@ dependencies {
 
     testCompile "me.eugeniomarletti.kotlin.metadata:kotlin-metadata:1.4.0"
     testCompile 'com.squareup:kotlinpoet:1.0.0-RC1'
+    testCompile 'com.squareup:javapoet:1.11.1'
 
     testImplementation "com.squareup.okio:okio:2.1.0"
     testImplementation 'io.github.classgraph:classgraph:4.6.10'

src/main/kotlin/com/tschuchort/compiletesting/Utils.kt

@@ -33,3 +33,6 @@ internal fun File.listFilesRecursively(): List<File> {
 
 internal fun File.isKotlinFile()
         = listOf("kt", "kts").any{ it.equals(extension, ignoreCase = true) }
+
+internal fun File.isJavaFile()
+        = listOf("java").any{ it.equals(extension, ignoreCase = true) }

src/test/java/com/tschuchort/compiletesting/JavaTestProcessor.java

@@ -2,7 +2,6 @@
 
 import com.squareup.javapoet.JavaFile;
 import com.squareup.kotlinpoet.FileSpec;
-import com.squareup.kotlinpoet.FunSpec;
 import com.squareup.kotlinpoet.TypeSpec;
 import kotlin.text.Charsets;
 
@@ -20,6 +19,11 @@
 
 public class JavaTestProcessor extends AbstractProcessor {
 
+    public static String ON_INIT_MSG = "java processor init";
+    public static String GENERATED_PACKAGE = "com.tschuchort.compiletesting";
+    public static String GENERATED_JAVA_CLASS_NAME = "JavaGeneratedJavaClass";
+    public static String GENERATED_KOTLIN_CLASS_NAME = "JavaGeneratedKotlinClass";
+
     @Override
     public SourceVersion getSupportedSourceVersion() {
         return SourceVersion.latestSupported();
@@ -28,7 +32,7 @@ public SourceVersion getSupportedSourceVersion() {
     @Override
     public Set<String> getSupportedAnnotationTypes() {
          LinkedHashSet<String> set = new LinkedHashSet<>();
-         set.add(Marker.class.getCanonicalName());
+         set.add(ProcessElem.class.getCanonicalName());
          return set;
     }
 
@@ -42,31 +46,29 @@ public Set<String> getSupportedOptions() {
     @Override
     public synchronized void init(ProcessingEnvironment processingEnv) {
         super.init(processingEnv);
-        processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "java processor init");
+        processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, ON_INIT_MSG);
     }
 
     @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 annotatedElem : roundEnv.getElementsAnnotatedWith(ProcessElem.class)) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING,
+                    new ProcessedElemMessage(annotatedElem.getSimpleName().toString()).print());
+        }
 
-            for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Marker.class)) {
-                typeSpecBuilder.addFunction(FunSpec.builder(annotatedElement.getSimpleName().toString()
-                        ).build()
-                ).build();
-            }
+        if(annotations.isEmpty()) {
+            TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder(GENERATED_KOTLIN_CLASS_NAME);
 
-            FileSpec fileSpec = FileSpec.builder("com.tschuchort.compiletesting", "JavaGeneratedKotlinClass.kt")
-                    .addType(typeSpecBuilder.build())
-                    .build();
+            FileSpec fileSpec = FileSpec.builder(GENERATED_PACKAGE, GENERATED_KOTLIN_CLASS_NAME + ".kt")
+                    .addType(typeSpecBuilder.build()).build();
 
             writeKotlinFile(fileSpec, fileSpec.getName(), fileSpec.getPackageName());
 
             try {
-                JavaFile.builder("com.tschuchort.compiletesting",
-                        com.squareup.javapoet.TypeSpec.classBuilder("JavaGeneratedJavaClass").build())
+                JavaFile.builder(GENERATED_PACKAGE,
+                        com.squareup.javapoet.TypeSpec.classBuilder(GENERATED_JAVA_CLASS_NAME).build())
                         .build().writeTo(processingEnv.getFiler());
             } catch (Exception e) {
             }

src/test/kotlin/SmokeTests.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.config.Services
+import org.jetbrains.kotlin.incremental.isJavaFile
 import java.io.*
 import java.lang.RuntimeException
 import java.util.zip.ZipEntry
@@ -156,20 +157,23 @@ data class KotlinCompilation(
 	// Directory for input source files
 	private val sourcesDir get() = File(workingDir, "sources")
 
+	// Base directory for kapt stuff
+	private val kaptDir get() = File(workingDir, "kapt")
+
 	// *.class files, Jars and resources (non-temporary) that are created by the
 	// compilation will land here
 	val classesDir get() = File(workingDir, "classes")
 
 	// Java annotation processors that are compile by kapt will put their generated files here
-	val kaptSourceDir get() = File(workingDir, "kapt/sources")
+	val kaptSourceDir get() = File(kaptDir, "sources")
 
 	// Output directory for Kotlin source files generated by kapt
 	val kaptKotlinGeneratedDir get() = kaptArgs[OPTION_KAPT_KOTLIN_GENERATED]
 		?.let { path ->
 			require(File(path).isDirectory) { "$OPTION_KAPT_KOTLIN_GENERATED must be a directory" }
 			File(path)
 		}
-		?: File(workingDir, "kapt/kotlinGenerated")
+		?: File(kaptDir, "kotlinGenerated")
 
 
 	/**
@@ -258,8 +262,9 @@ data class KotlinCompilation(
 	/** Performs the 1st and 2nd compilation step to generate stubs and run annotation processors */
 	private fun stubsAndApt(messageCollector: PrintingMessageCollector): ExitCode {
 		// stubs and incrementalData are temporary
-		val kaptStubsDir = File(workingDir, "kapt/stubs").apply { mkdirs() }
-		val kaptIncrementalDataDir = File(workingDir, "kapt/incrementalData").apply { mkdirs() }
+		val kaptStubsDir = File(kaptDir, "stubs").apply { mkdirs() }
+		val kaptIncrementalDataDir = File(kaptDir, "incrementalData").apply { mkdirs() }
+		kaptKotlinGeneratedDir.mkdirs()
 
 		require(kapt3Jar != null) { "kapt3Jar has to be non-null if annotation processing is used" }
 
@@ -280,19 +285,38 @@ data class KotlinCompilation(
 			// write unsafe context
 			"plugin:org.jetbrains.kotlin.kapt3:aptMode=stubsAndApt",
 			"plugin:org.jetbrains.kotlin.kapt3:mapDiagnosticLocations=true",
+			"plugin:org.jetbrains.kotlin.kapt3:apoptions=$encodedKaptArgs",
 			*if (verbose)
 				arrayOf("plugin:org.jetbrains.kotlin.kapt3:verbose=true")
-			else
-				emptyArray(),
-			*if (kaptArgs.isNotEmpty())
-				arrayOf("plugin:org.jetbrains.kotlin.kapt3:apoptions=$encodedKaptArgs")
 			else
 				emptyArray()
 		)
+
+		val kotlinSources = sourcesDir.listFilesRecursively().filter(File::isKotlinFile)
+		val javaSources = sourcesDir.listFilesRecursively().filter(File::isJavaFile)
+
+		val allSourcePaths = mutableListOf<File>().apply {
+			addAll(javaSources)
+
+			if(kotlinSources.isNotEmpty()) {
+				addAll(kotlinSources)
+			}
+			else {
+				/* __HACK__: The K2JVMCompiler expects at least one Kotlin source file or it will crash.
+				   We still need kapt to run even if there are no Kotlin sources because it executes APs
+				   on Java sources as well. Alternatively we could call the JavaCompiler instead of kapt
+				   to do annotation processing when there are only Java sources, but that's quite a lot
+				   of work (It can not be done in the compileJava step because annotation processors on
+				   Java files might generate Kotlin files which then need to be compiled in the
+				   compileKotlin step before the compileJava step). So instead we trick K2JVMCompiler
+				   by just including an empty .kt-File. */
+				add(SourceFile("emptyKotlinFile.kt", "").writeTo(kaptDir))
+			}
+
+		} .map(File::getAbsolutePath).distinct()
 
 		val k2JvmArgs = commonK2JVMArgs().also {
-			it.freeArgs = sourcesDir.listFilesRecursively()
-				.map(File::getAbsolutePath).distinct() + addKotlincArgs
+			it.freeArgs = allSourcePaths + addKotlincArgs
 
 			it.pluginOptions = if(it.pluginOptions != null)
 				it.pluginOptions!!.plus(kaptPluginOptions)
@@ -315,6 +339,7 @@ data class KotlinCompilation(
 				kaptKotlinGeneratedDir.listFilesRecursively() +
 				kaptSourceDir.listFilesRecursively())
 
+		// if no Kotlin sources are available, skip the compileKotlin step
 		if(sources.filter<File>(File::isKotlinFile).isEmpty())
 			return ExitCode.OK