Is there any equivalent in KSP for

javax.lang.model.element.PackageElement

? As far as I can tell there isn’t a

KSAnnotated

representation of a package (potentially because package-info.java is not used in kotlin?) I have a javac processor that looks up annotations on package elements and am wondering how KSP handles that. Similarly, does KSP provide any way to resolve the package by name? In javac we can do

Elements.getPackageElement(CharSequence)

to get a package, which then provides access to all elements in that package (including elements from other modules). We have used this to enable a single module to aggregate the generated files of other modules, by putting them all in the same package. I’m trying to figure out how to translate this to KSP

See docs/reference.md. There isn’t such thing in KSP directly, you can still inspect package names, but there is no KSP representation for package itself.

Thanks, I should have checked there first 😅 But yes, I think that leaves the question of how to support existing javac processors that heavily rely on these APIs. I started working on adding KSP support to the handful of libraries we own with annotation processors, and this is a bit of a blocker for them. Curious to hear what you can think of 🙏

I am thinking about providing some API to return a list of symbols given a package name, in that case no package level symbols is introduced but should still serve your purpose (I feel this should be sufficient for practical use cases looking at PackageElement)

I think that would be great, and would cover our only use case of it. (And this would return symbols outside of the currently compiling module, correct?)

Sounds good, I’ll take a note on this.

great, I was thinking the same, just double checking. Thank you very much! 🙏

Hi, some follow up here. From what you asked in original thread, it looks like it is not involving annotations, and we can achieve same thing with a byte code visitor that visits byte code in classpath, which can also be more efficient without intermediate wrapping of KSP and kotlin compiler. Is your project open source? if so may I take a look at the code to see what’s the exact use case and evaluate?

That’s right, it doesn’t involve annotations, so visiting byte code sounds reasonable if it is able to be supported. Here’s an example in Showkase which generates a gallery of @Composable UI views. Data about each composable is written to a file in a hardcoded package: https://github.com/airbnb/Showkase/blob/master/showkase-processor/src/main/java/co[…]roid/showkase/processor/writer/ShowkaseCodegenMetadataWriter.kt Then a single module can read the generated files from all other modules to gather them together into the gallery it displays: https://github.com/airbnb/Showkase/blob/master/showkase-processor/src/main/java/com/airbnb/android/showkase/processor/ShowkaseProcessor.kt#L235 This allows us to write composables in many modules, and then have our single application module that depends on all library modules aggregate files together and further process all of them

KSP is unlikely to provide a byte code visitor since it seems out of scope for an annotation processor. I wonder how feasible it will be for you to write a byte code visitor to load the classes, and once you get the classes (just names will work) you still have full access to other KSP APIs, like checking annotations you did in the code you linked.

I could try writing a byte code visitor if you’re able to point me in the right direction to get started. A general purpose byte code visitor does seem out of scope, but since the root of our use case is to allow a module to access files generated by KSP in other modules that use case seems in scope. Or put another way, it could be in scope to be able to process annotations from binaries

It is possible to process annotations from binaries, but the limitation is that you can’t call

getSymbolsAnnotatedWith

to get the symbols from binaries, this can be hard to implement and also expensive. I am trying to explore alternate options before I can make a commitment on whether KSP will provide such API for getting symbols from a package, since a package symbol is most likely for Java rather than for Kotlin.

thank you for continuing to think it through 🙏

I’m also processing many modules and generating intermediate classes so that once I hit the aggregating module I could just access them through their package. Now, for that use-case in particular, what is interesting is not exactly to be able to fetch symbols within a package from dependency modules, but more specifically to have a way we can pre-process each module and finish processing of all of these symbols once we reach the bottom module that will aggregate everything. Doing so through package was just the way found to do it through javaAP, but in terms of API idk if that’s the optimal path, It’s what we get used to and good to port javaAP code to KSP, but that’s it.

Hi @Jiaxiang I’m wondering if you have any updates to share on this at all. Would it be helpful if I created an issue on Github so this work could be tracked easier?

Oops sorry for the long wait, I thought I’ve updated here. KSP itself is unlikely to provide package symbols directly, but we do plan to support it either as an experimental API like

getJvmName()

, or support it in another module, potentially Room’s abstraction layer. Yes please file an issue on Github.

Created the issue, https://github.com/google/ksp/issues/372, thanks!