Synthetic classes for top level kotlin files

[yigit]

I'm trying to figure out how to model top level properties in kotlin, specifically the synthetic classes generated for them.

From my testing, it seems like KSP's behavior is a bit inconsistent between pre-compiled code and source core.
Moreover, it fails to resolve the type of a java field if the type of it is inferred from a kotlin file.

see the sample test below:

@Test
    fun preCompiled2() {
        val libKotlin = Source.kotlin("lib/MyFile.kt",
        """
            package lib;
            fun myMethod() {}
        """.trimIndent())
        val libJava = Source.java("lib.MyJava",
        """
            package lib;
            public class MyJava {
                MyFileKt kotlinFileRef;
            }
        """.trimIndent())

        val mainKotlin = Source.kotlin("main/MyFile.kt",
            """
            package main;
            fun myMethod() {}
        """.trimIndent())
        val mainJava = Source.java("main.MyJava",
            """
            package main;
            public class MyJava {
                MyFileKt kotlinFileRef;
            }
        """.trimIndent())
        val classpath = listOf(compileFiles(listOf(libJava, libKotlin)))
        runKspTest(
            sources = listOf(mainJava, mainKotlin),
            classpath = classpath
        ) { invocation ->
            val resolver = invocation.kspResolver
            val readings = listOf("lib", "main").map { pkg ->
                val firstReadOfKotlinFile = resolver.getClassDeclarationByName("$pkg.MyFileKt")
                // now read via java
                val javaClass = resolver.getClassDeclarationByName("$pkg.MyJava")!!
                val javaPropToKotlinFileClass = javaClass.declarations.first {
                    it.simpleName.asString() == "kotlinFileRef"
                } as KSPropertyDeclaration
                val declarationViaJava = javaPropToKotlinFileClass.type.resolve()
                val secondReadOfKotlinFile = resolver.getClassDeclarationByName("$pkg.MyFileKt")
                pkg to Triple(
                    first = firstReadOfKotlinFile,
                    second = declarationViaJava,
                    third = secondReadOfKotlinFile,
                )
            }
            println(readings)

        }
    }

This prints:

lib -> (null, (lib.MyFileKt..lib.MyFileKt?), null)
main -> (null, <ERROR TYPE>, null)

Basically, when a Java class in source references a KSFile synthetic class, it works if it is coming from a compiled dependency whereas KSP fails to resolve it if it is in source.
In both cases, getClassDeclarationByName fails to resolve the synthetic class.

It is possible that not finding it in getClassDeclarationByName can be considered a feature, not a bug. On the other hand, KSP should still be able to resolve those types when java files in source references them.

Moreover, supporting getClassDeclarationByName might also make sense to ease KAPT -> KSP transitions.

cc: @gfreivasc, @elihart

[yigit]

a bit more information on this.

I don't think snythesizing a class in KSP is the right way to go because the KSType does not really exist and it is bound to explode in some cases (at least that is what happened when i tried to do it in Room).

I "think" a nicer solution might be to provide a method in KspResolver to get the qName for that synthetic class.
That way, java code that accesses those methods can be generated without adding classes that do not really exist in the KSP realm.