The reason that putting annotation processors on the compile classpath is deprecated is to support incremental annotation processing:
https://docs.gradle.org/4.7-rc-2/userguide/java_plugin.html#sec:incremental_annotation_processing

From the 4.6 Release Notes:

Putting processors on the compile classpath or using an explicit -processorpath compiler argument has been deprecated and will be removed in Gradle 5.0. Annotation processors should be added to the annotationProcessor configuration instead.

If Lombok does not want to split its JAR file into api/processor that's fine, but users will then have to add its single JAR to both the compileOnly and the annotationProcessor configuration.

We'll update our documentation for gradle to take this into account.

Annotation processors belong on the processor path, not the compile classpath. Note that this is not related to incremental annotation processing, but about compile avoidance. It's about proper separation of concerns. On the compile classpath only the ABI should matter, while on the processor path every implementation detail matters for the correct compilation result. That's why we will ignore them on the compile classpath in the future.

@oehme this is overzealous. Take gradle. Do you require gradle to split into two packages; one with only interfaces, and one with implementations? They'd have to start with even making a bunch of interfaces first. What about a project that has two related but technically separate concepts in it; such that it is imaginable a project will only use one of the two features (though most projects use both): Should gradle detect this and error?

There's an ocean between 'this would be an ideal API design for the library' and 'gradle will enforce this at, effectively, gunpoint'.

As long as putting lombok on both the compileOnly path and the annotationProcessor path works out fine (and without any warnings), all is well.

It's not about having things on the compile classpath that you may not use. That's fine. It's about the fact the annotation processors change the behavior of the compiler itself and thus need to be treated very differently from normal classes.

When Gradle snapshots the compile classpath, it will only look at the API of a class, thus avoiding recompilation if the API didn't change. On the processor path that optimization can't be done, since obviously the result of processing depends on its implementation.

So if a user puts a processor on the compile classpath, we have to shut that optimization off, making their incremental builds slower. That's why we are deprecating this and will ignore processors on the compile classpath in the future. I don't know why the JDK team decided to allow this in the first place (probably because Maven couldn't fit the processorPath into its anemic model), but it's definitely not a good idea.

As long as putting lombok on both the compileOnly path and the annotationProcessor path works out fine (and without any warnings), all is well.

It will.

Sounds good. One last thing:

Right now if a jar-with-processor is on the compileOnly path, you get the warning.

Let's say it's on the compileOnly path and the annotationProcessor path. Do you still get this warning?

The warning will disappear as soon as you start using annotationProcessor.

The reason is backwards compatiblity. Putting processors on the compile classpath worked before, so we need to keep it working till 5.0. Gradle will currently fall back to the compile classpath if the annotationProcessor configuration is empty. As soon as you use it, processors on the compile classpath are ignored.

Folks, I am late to the party and a gradle novice.

I it not clear from the error message how to fix the problem.

The following does not resolve the problem:

compileJava {
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    options.compilerArgs += ["-proc:none"]
}

Any pointers?

The annotation process in question is from org.apache.logging.log4j.core.config.plugins.processor.PluginProcessor

Also here is my gradle version information:

$ ./gradlew -version

------------------------------------------------------------
Gradle 4.7
------------------------------------------------------------

Build time:   2018-04-18 09:09:12 UTC
Revision:     b9a962bf70638332300e7f810689cb2febbd4a6c

Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.9 compiled on February 2 2017
JVM:          1.8.0_162 (Oracle Corporation 25.162-b12)
OS:           Mac OS X 10.13.4 x86_64

Thank-You
Stuart

@sasconsul I can't tell for sure without least the full message or ideally a build scan or sample project. My suspicion is that the message is coming from test compilation, but you only deactivated processing for the main compile task.

@oehme you are right the problem is in the compiletestJava task -- I did not notice when reading the message:

> Task :compileTestJava UP-TO-DATE
The following annotation processors were detected on the compile classpath: 'org.apache.logging.log4j.core.config.plugins.processor.PluginProcessor'. Detecting annotation processors on the compile classpath is deprecated and Gradle 5.0 will ignore them. Please add them to the annotation processor path instead. If you did not intend to use annotation processors, you can use the '-proc:none' compiler argument to ignore them.