are java-generating annotation processors supported in new MPP for jvm targets? the processor is running as i see .java files generated, but they are not compiled (even with

withJava()

). I see mention of Android support in the docs but nothing about jvm targets.

I see

Caused by: java.lang.NullPointerException
        at jdk.compiler/com.sun.tools.javac.util.JDK9Wrappers$Module.getModule(JDK9Wrappers.java:201)
        at jdk.compiler/com.sun.tools.javac.processing.JavacProcessingEnvironment.initProcessorLoader(JavacProcessingEnvironment.java:270)
        at jdk.compiler/com.sun.tools.javac.processing.JavacProcessingEnvironment.<init>(JavacProcessingEnvironment.java:235)
        at jdk.compiler/com.sun.tools.javac.processing.JavacProcessingEnvironment.instance(JavacProcessingEnvironment.java:192)
        at org.jetbrains.kotlin.kapt3.base.AnnotationProcessingKt.doAnnotationProcessing(annotationProcessing.kt:38)
        at org.jetbrains.kotlin.kapt3.base.AnnotationProcessingKt.doAnnotationProcessing$default(annotationProcessing.kt:36)

hello all, I’m trying to debug a custom annotation processor but I’m failing to be able to stop the debugger - already tried a couple of suggestions from: - https://discuss.kotlinlang.org/t/debug-annotation-processor-kapt/11369 but without any luck. I’m currently trying to run:

./gradlew --no-daemon :app:clean :app:compileDebugKotlin -Dkotlin.daemon.jvm.options="-Xdebug,-Xrunjdwp:transport=dt_socket\,address=5005\,server=y\,suspend=n"

and then to attach a remote configuration

So, after months of research, I feel like

kapt

is very much a "here be dragons" region of Kotlin. Is that a fair assessment?

Is anyone, community or JB, working on concerted, focused efforts to make reflectionless metaprogramming in Kotlin more accessible to the masses?

I am making an annotation processor that generates Kotlin source files using Kotlin poet, however I am unsure how can I make incremental processing work properly. The problem is that outdated source files don't get deleted. How can I "mark" generated Kotlin source file as being outdated and that they need to be deleted? Example:

@NbtSerializable
class Foo // --> Generates source file named "FooUtil"

Now I remove

@NbtSerializable

and need

FooUtil

to be deleted as well.

Is there a way to know from the annotations API if an element type is nullable?

Is there setup example how to build android app with annotation processing and kapt with JDK9+?

Why kapt needs

java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

?

When writing a custom annotation processor, what is the easiest way to check that a method is a

suspend

method?

or is there a way to restrict custom annotations to suspend methods?

is

kapt.use.worker.api=true

still necessary with 1.3.50?

Guys, I volunteer to provide you all information or details you need to reproduce/check the kapt issues with cache and workers

What do you suggest?

what’s the best way to break stale kapt cache? I’m having issues where old generated files are being picked up and fail to compile.

Is it possible to turn off kapt cache by the gradle property?

What

detectMemoryLeaks

kapt option does? https://github.com/JetBrains/kotlin/blob/6bddfa806c44936586c2201c038217abb17047a8/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KaptExtension.kt#L38

looking at this issue with Android’s Room project (room asking for an output dir for schemas) - https://issuetracker.google.com/issues/139438151. The crux of the issue there is that it puts an absolute path in apt options, which breaks remote cache. Doesn’t that mean that kapt’s

"kapt.kotlin.generated"

option is also not compatible with remote caching? It uses an absolute path as well

for some reason if i use kapt in my project compiler is throwing

bad RuntimeInvisibleParameterAnnotations

if i use java enum class as parameter or return type

Basically at a core my question is "I'm using kapt to run a processor from a project. That project has a dependency on another project in my multi-project. Is there a way to have kapt run against that project dependency, but generate files in the current project"?

Hey, I’m building a Gradle plugin that adds some dependencies based on an extension value but if the dependency is added in the

afterEvaluate

Kapt doesn’t run. Any idea? Here the example:

class MyPlugin : Plugin<Project> {

    override fun apply(project: Project) {
        with(project) {
            val extension = extensions.create("projectConfiguration", MyExtension::class.java)
            
            // Adding the dependency in the apply works
            addDependency("kapt", "library-coordinate")
            
            // If the dependency is added in the afterEvaluate block kapt doesn't run.
            // :myproject:dependencies shows the dependency properly
            afterEvaluate {
                if (extension.value) {
                    addDependency("kapt", "library-coordinate")
                }
            }
        }
    }

    private fun Project.addDependency(configuration: String, dependency: String) {
        dependencies.add(configuration, dependency)
    }
}

what if you build with

--no-build-cache

and

--rerun-tasks

after a clean? The full nuclear option

I have a multi module Android project. The :app: module is mixed Kotlin and Java. I have KAPT incremental enabled. When I add a new private function to a ViewModel class KAPT appears to process every source file in the :app: module despite being able to identify the changed file. Is this expected? Android Gradle Plugin: 3.5.3 Kotlin version: 1.3.61 Gradle version: 5.6 Some KAPT verbose output:

[INFO] Kapt3 is enabled (stand-alone mode).
Annotation processing mode: apt
Memory leak detection mode: none
Show processor time: false
Verbose mode: true
Info as warnings: false
Use light analysis: false
Correct error types: false
Map diagnostic locations: false
Strict mode: false
Detect annotation processors in compile classpath: false
Incremental annotation processing (apt mode): true
Javac options: {-Xmaxerrs=500, -source=1.8}
[incremental apt] Changed files: [/path/to/file/changed/ViewModel.java] <- Correctly identifies changed file
[INFO] Processing java sources with annotation processors: [list of what looks like all source files in the app module]

Annotation processors in app module:

dagger.internal.codegen.ComponentProcessor
dagger.android.processor.AndroidProcessor
com.squareup.inject.assisted.dagger2.processor.AssistedInjectDagger2Processor
androidx.lifecycle.LifecycleProcessor
com.squareup.moshi.kotlin.codegen.JsonClassCodegenProcessor
butterknife.compiler.ButterKnifeProcessor
android.databinding.annotationprocessor.ProcessDataBinding
com.squareup.inject.assisted.processor.AssistedInjectProcessor

The memory usage of the kotlin compiler daemon for our project reached 10Gb threshold. If we set it lower kotlin daemon dies out with OOM.  It dies during the kapt processing. That’s why I’m trying to reach out to this channel. Wonder if anyone else experienced similar issues. The heap dump looks pretty similar to the one in this issue (https://youtrack.jetbrains.com/issue/KT-32962). But there is no leak in our case. There is only one instance of IncrementalProcessingEnvironment. Also with 10gb heap limit the memory goes down to normal level after annotation processing finished. We had a suspicion that it had something to do with the generation of the @Metadata annotations on the stubs (A big chunk of heap is consumed by the flatbuffer strings). We did a quick hack to strip those annotations out of stubs generated by kapt but it doesn’t seem to be helping much. We have a BUCK build configured and it doesn’t have such problem (it doesn't use kotlin daemon though). Right now we have to hypothesizes: 1. There is something wrong with our gradle script or kotlin gradle plugin. It would be awesome if someone could give a pointer how to enable the logs of the kotlin daemon launched from the gradle plugin, ie how to tweak the verbosity level of the daemon and where to find logs on Mac/Linux. 2. It might be the case that kapt extension keeps more resources than it is needed for the processing. Currently the code for the resources release in kapt looks like this (https://github.com/JetBrains/kotlin/blob/2552540f7165571dd2fdefdef4f09d858e4fa92a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt#L101-L104). We wonder if there is a way to say release some of the resources between different annotation processors runs?  Most of our codebase is Kotlin, so literally every file in the project has the Metadata annotations and corresponding overhead. Is there a way to ignore those data completely during the kapt processing? What would be consequences of doing it? Maybe there are some known kapt options that could potentially help mitigate the issue/reduce the memory footprint? Our gradle.properties for kapt now:

# See: <https://youtrack.jetbrains.com/oauth?state=%2Fissue%2FKT-17621>
kotlin.incremental.usePreciseJavaTracking=true
# Configure the Kotlin Gradle plugin to run tasks in parallel within a project.
# <https://blog.jetbrains.com/kotlin/2019/01/kotlin-1-3-20-released/>
kotlin.parallel.tasks.in.project=true
# There is a cache key inconsistency when enabling this
# Disable incremental kapt locally to avoid this
# <https://youtrack.jetbrains.com/issue/KT-31840>
kapt.incremental.apt=false
# Skips annotation processing completely when there are no changes in kapt stubs and only method
# bodies are changed in dependencies. See <https://blog.jetbrains.com/kotlin/2019/01/kotlin-1-3-20-released/>
kapt.include.compile.classpath=false

can I use kapt to run java annotation processors over java source code only? when I am trying to do this I always get:

[WARNING] No sources found skipping Kotlin compile

Upgraded to Kotlin 1.3.70 and a project is not compiling anymore with below error. I always have

allWarningsAsErrors

active to ensure that people do not ignore warnings but this was no warning previously and I also don’t think that it should be a warning.

hello all, I’ve got a ( minor issue here) but I wanted to understand what I might be doing wrong. I’ve created a module which generates a couple of classes on compile time; but when I want to print any messages they are all printed on the same line - I’ve already tried out a couple of variations with \n. I’m using:

_messager_.printMessage(Diagnostic.Kind.NOTE, "test 1\n")

_messager_.printMessage(Diagnostic.Kind.NOTE, "test 2")

any idea what I’m doing wrong?

I've noticed following message in build scan logs (Kotlin 1.3.71):

Overlapping outputs: Gradle does not know how file 'build/generated/source/kaptKotlin/debug' was created (output property 'kotlinSourcesDestinationDir'). Task output caching requires exclusive access to output paths to guarantee correctness.

This is happens after full project clean and I could not figure out some pattern here. Do anyone else see the same?

I'm having an issue where applying the kapt plugin in gradle prevents it from running other java annotation processors during

compileJava

. Any idea why that could be happening?