Report INNER modifier for class desciptors

This PR fixes a bug where the inner modifier would be lost if the
kotlin sources is in dependencies (when wrapped in a descriptor).

Unfortunately, for descriptors, there is no easy way to distinguish
between JAVA_STATIC and INNER. That is, if a java nested class that is
annotated with STATIC is compiled, descriptor API will no longer report
any modifiers for it. Similarly, if a Java inner class (that has no
static annotation) is compiled, we'll start reporting INNER for it.
Even though this is slightly confusing, it is at least consistent from a
kotlin perspective.

Also fixed a bug in multi-module testing setup where we were NOT
compiling java sources in test modules.

Fixes: #231
Test: javaModifiers

more test cases

report inner for descriptors

Author: yigit

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/processor/JavaModifierProcessor.kt

@@ -30,8 +30,13 @@ class JavaModifierProcessor : AbstractTestProcessor() {
     }
 
     override fun process(resolver: Resolver) {
-        val symbol = resolver.getSymbolsWithAnnotation("Test").single() as KSClassDeclaration
-        symbol.superTypes.single().resolve()!!.declaration.accept(ModifierVisitor(), Unit)
+        resolver.getSymbolsWithAnnotation("Test")
+            .map {
+                it as KSClassDeclaration
+            }
+            .forEach {
+                it.superTypes.single().resolve().declaration.accept(ModifierVisitor(), Unit)
+            }
     }
 
     inner class ModifierVisitor : KSTopDownVisitor<Unit, Unit>() {

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/binary/KSClassDeclarationDescriptorImpl.kt

@@ -117,6 +117,9 @@ class KSClassDeclarationDescriptorImpl private constructor(val descriptor: Class
         if (descriptor.kind == KtClassKind.ANNOTATION_CLASS) {
             modifiers.add(Modifier.ANNOTATION)
         }
+        if (descriptor.isInner) {
+            modifiers.add(Modifier.INNER)
+        }
         modifiers
     }
 

compiler-plugin/src/test/kotlin/com/google/devtools/ksp/test/AbstractKotlinKSPTest.kt

@@ -101,7 +101,12 @@ abstract class AbstractKotlinKSPTest : KotlinBaseTest<AbstractKotlinKSPTest.KspT
         dependencies: List<File>,
         testProcessor: AbstractTestProcessor?) {
         val moduleRoot = module.rootDir
-        module.writeJavaFiles(testFiles)
+        val hasJavaSources = testFiles.any {
+            it.isJavaFile()
+        }
+        if (hasJavaSources) {
+            module.writeJavaFiles(testFiles)
+        }
         val configuration = createConfiguration(
             ConfigurationKind.NO_KOTLIN_REFLECT,
             TestJdkKind.FULL_JDK_9,
@@ -140,6 +145,23 @@ abstract class AbstractKotlinKSPTest : KotlinBaseTest<AbstractKotlinKSPTest.KspT
             GenerationUtils.compileFiles(moduleFiles.psiFiles, environment, ClassBuilderFactories.TEST)
         } else {
             GenerationUtils.compileFilesTo(moduleFiles.psiFiles, environment, outDir)
+            if (hasJavaSources) {
+                // need to compile java sources as well
+                val javaOutDir = module.rootDir.resolve("javaOut")
+                val classpath = (dependencies + KotlinTestUtils.getAnnotationsJar() + module.outDir)
+                    .joinToString(":") { it.absolutePath }
+                val options = listOf(
+                    "-classpath", classpath,
+                    "-d", javaOutDir.absolutePath
+                )
+                val javaFiles = module.javaSrcDir.listFilesRecursively()
+                KotlinTestUtils.compileJavaFiles(
+                    javaFiles,
+                    options
+                )
+                // merge java outputs into module's out dir
+                javaOutDir.copyRecursively(target = module.outDir, overwrite = false)
+            }
         }
     }
 
@@ -187,6 +209,14 @@ abstract class AbstractKotlinKSPTest : KotlinBaseTest<AbstractKotlinKSPTest.KspT
     private val TestModule.outDir:File
         get() = File(rootDir, "out")
 
+    private fun KspTestFile.isJavaFile() = name.endsWith(".java")
+
+    private fun File.listFilesRecursively(): List<File> = if (!this.exists()) {
+        emptyList()
+    } else {
+        this.walkTopDown().filter { it.isFile }.toList()
+    }
+
     /**
      * TestFile class for KSP where we can also keep a reference to the [TestModule]
      */

compiler-plugin/testData/api/javaModifiers.kt

@@ -21,9 +21,35 @@
 // staticStr: PRIVATE
 // s1: FINAL JAVA_TRANSIENT
 // i1: PROTECTED JAVA_STATIC JAVA_VOLATILE
+// NestedC: PUBLIC JAVA_STATIC
+// InnerC: PUBLIC
 // intFun: JAVA_SYNCHRONIZED JAVA_DEFAULT
 // foo: ABSTRACT JAVA_STRICT
+// OuterJavaClass: PUBLIC
+// InnerJavaClass: PUBLIC
+// NestedJavaClass: PUBLIC JAVA_STATIC
+// OuterKotlinClass: OPEN
+// InnerKotlinClass: INNER
+// NestedKotlinClass: OPEN
+// DependencyOuterJavaClass: OPEN PUBLIC
+// DependencyNestedJavaClass: OPEN PUBLIC
+// DependencyInnerJavaClass: OPEN PUBLIC INNER
+// DependencyOuterKotlinClass: OPEN PUBLIC
+// DependencyInnerKotlinClass: FINAL PUBLIC INNER
+// DependencyNestedKotlinClass: OPEN PUBLIC
 // END
+// MODULE: module1
+// FILE: DependencyOuterJavaClass.java
+public class DependencyOuterJavaClass {
+    public class DependencyInnerJavaClass {}
+    public static class DependencyNestedJavaClass {}
+}
+// FILE: DependencyOuterKotlinClass.kt
+open class DependencyOuterKotlinClass {
+    inner class DependencyInnerKotlinClass
+    open class DependencyNestedKotlinClass
+}
+// MODULE: main(module1)
 // FILE: a.kt
 annotation class Test
 
@@ -32,6 +58,18 @@ class Foo : C() {
 
 }
 
+@Test
+class Bar : OuterJavaClass()
+
+@Test
+class Baz : OuterKotlinClass()
+
+@Test
+class JavaDependency : DependencyOuterJavaClass()
+
+@Test
+class KotlinDependency : DependencyOuterKotlinClass()
+
 // FILE: C.java
 
 public abstract class C {
@@ -47,4 +85,23 @@ public abstract class C {
     }
 
     abstract strictfp void foo() {}
+
+    public static class NestedC {
+
+    }
+
+    public class InnerC {
+
+    }
+}
+
+// FILE: OuterJavaClass.java
+public class OuterJavaClass {
+    public class InnerJavaClass {}
+    public static class NestedJavaClass {}
+}
+// FILE: OuterKotlinClass.kt
+open class OuterKotlinClass {
+    inner class InnerKotlinClass
+    open class NestedKotlinClass
 }