This plugin configures JavaCompile tasks to use the Error Prone compiler.

This plugin requires using at least Gradle 5.2.

While JDK 8 is supported, it is recommended to use at least a JDK 9 compiler. See note below about JDK 8 support.

plugins {
    id("net.ltgt.errorprone") version "<plugin version>"
}

Note: snippets in this guide use features from the latest Gradle version, so beware if copy/pasting.

This plugin creates a configuration named errorprone, and configures the <sourceSet>AnnotationProcessor configuration for each source set to extend it. This allows configuring Error Prone dependencies from a single place.

Error Prone needs to be added as a dependency in this configuration:

repositories {
    mavenCentral()
}
dependencies {
    errorprone("com.google.errorprone:error_prone_core:$errorproneVersion")
}

CAUTION: Using a dynamic or changing version for Error Prone, such as latest.release or 2.+, means that your build could fail at any time, if a new version of Error Prone adds or enables new checks that your code would trigger.

Error Prone can then be configured on the JavaCompile tasks:

tasks.withType(JavaCompile).configureEach {
    options.errorprone.disableWarningsInGeneratedCode = true
}

import net.ltgt.gradle.errorprone.errorprone

tasks.withType<JavaCompile>().configureEach {
    options.errorprone.disableWarningsInGeneratedCode.set(true)
}

and can also be disabled altogether:

tasks.named("compileTestJava").configure {
    options.errorprone.enabled = false
}

tasks.named<JavaCompile>("compileTestJava") {
    options.errorprone.isEnabled.set(false)
}

Note that this plugin only enables Error Prone on tasks for source sets (i.e. compileJava for the main source set, compileTestJava for the test source set, and compileIntegTestJava for a custom integTest source set). If you're creating custom JavaCompile tasks, then you'll have to configure them manually to enable Error Prone:

tasks.register("compileCustom", JavaCompile) {
    source "src/custom/"
    include "**/*.java"
    classpath = configurations.custom
    sourceCompatibility = "8"
    targetCompatibility = "8"
    destinationDir = file("$buildDir/classes/custom")

    // Error Prone must be available in the annotation processor path
    options.annotationProcessorPath = configurations.errorprone
    // Enable Error Prone
    options.errorprone.enabled = true
    // It can then be configured for the task
    options.errorprone.disableWarningsInGeneratedCode = true
}

tasks.register<JavaCompile>("compileCustom") {
    source("src/custom/")
    include("**/*.java")
    classpath = configurations["custom"]
    sourceCompatibility = "8"
    targetCompatibility = "8"
    destinationDir = file("$buildDir/classes/custom")

    // Error Prone must be available in the annotation processor path
    options.annotationProcessorPath = configurations["errorprone"]
    // Enable Error Prone
    options.errorprone.isEnabled.set(true)
    // It can then be configured for the task
    options.errorprone.disableWarningsInGeneratedCode.set(true)
}

Error Prone requires at least a JDK 9 compiler. When using a JDK 8 compiler, you can configure a dependency on the Error Prone javac in the errorproneJavac configuration:

dependencies {
    errorproneJavac("com.google.errorprone:javac:9+181-r4173-1")
}

and the plugin will configure the JavaCompile tasks to use a forking compiler and will override the compiler by prepending the dependencies to the bootstrap classpath (using a -Xbootclasspath/p: JVM argument).

Starting with Gradle 6.7, you can configure JavaCompile tasks to use a specific JDK compiler, independently of the JDK used to run Gradle itself. The plugin will use the toolchain version, if any is specified, to configure the task. This allows you to enforce compilation with JDK 8 (properly configured for Error Prone!) while running Gradle with e.g. JDK 11, or the reverse: enforce compilation with JDK 11 while running Gradle with JDK 8.

Alternatively, or for previous versions of Gradle, you can configure JavaCompile tasks to use such a JDK while still using JDK 8 for running Gradle:

tasks.withType(JavaCompile).configureEach {
    options.fork(javaHome: project.getProperty("jdk11home"))
}

tasks.withType<JavaCompile>().configureEach {
    options.fork = true
    options.forkOptions.javaHome = project.getProperty("jdk11home")
}

The plugin will try to detect those cases and won't configure the bootstrap classpath in this case, but to play safe it will actually ignore any task that forks and defines either a javaHome or an executable (this also means that it won't configure the bootstrap classpath if you're e.g. running Gradle with a more recent JDK and forking the compilation tasks to use JDK 8).

If you need it, you can configure the bootstrap classpath manually for those tasks that the plugin would have skipped:

someTask.configure {
    // …

    inputs.files(configurations.errorproneJavac).withNormalizer(ClasspathNormalizer)
    doFirst {
        options.forkOptions.jvmArgs += "-Xbootclasspath/p:${configurations.errorproneJavac.asPath}"
    }
}

someTask.configure {
    // …

    inputs.files(configurations.errorproneJavac).withNormalizer(ClasspathNormalizer::class)
    doFirst {
        options.forkOptions.jvmArgs.add("-Xbootclasspath/p:${configurations["errorproneJavac"].asPath}")
    }
}

(if you're using forkOptions.executable, then use -J-Xbootclasspath/p: instead.)

Starting with JDK 16, due to JEP 396: Strongly Encapsulate JDK Internals by Default, --add-opens and --add-exports arguments need to be passed to the compiler's JVM.

The plugin will automatically use a forking compiler and pass the necessary JVM arguments whenever it detects such a JDK is being used and ErrorProne is enabled.

That detection will only take into account the toolchain used by the JavaCompile task, or the JDK used to run Gradle in case no toolchain is being used. The plugin will ignore any task that forks and defines either a javaHome or an executable, so you would have to configure those JVM arguments yourself in this case. See the ErrorProne docs for the full list of --add-opens and --add-exports needed (use -J--add-opens if using executable, --add-opens if using javaHome).

Custom Error Prone checks can be added to the errorprone configuration too:

dependencies {
    errorprone("com.uber.nullaway:nullaway:$nullawayVersion")
}

or alternatively to the <sourceSet>AnnotationProcessor configuration, if they only need to be enabled for a given source set:

dependencies {
    annotationProcessor("com.google.guava:guava-beta-checker:$betaCheckerVersion")
}

and can then be configured on the tasks; for example:

tasks.withType(JavaCompile).configureEach {
    options.errorprone {
        option("NullAway:AnnotatedPackages", "net.ltgt")
    }
}
tasks.named("compileJava").configure {
    // The check defaults to a warning, bump it up to an error for the main sources
    options.errorprone.error("NullAway")
}

tasks.withType<JavaCompile>().configureEach {
    options.errorprone {
        option("NullAway:AnnotatedPackages", "net.ltgt")
    }
}
tasks.named("compileJava", JavaCompile::class) {
    // The check defaults to a warning, bump it up to an error for the main sources
    options.errorprone.error("NullAway")
}

As noted above, this plugin adds an errorprone extension to the JavaCompile.options. It can be configured either as a property (options.errorprone.xxx = …) or script block (options.errorprone { … }).

In a *.gradle.kts script, the Kotlin extensions need to be imported:

import net.ltgt.gradle.errorprone.errorprone

Please note that all properties are lazy, so while you can use = in place of .set(…) in the Groovy DSL, you cannot use << or += to add to lists for instance.

A check severity can take values: DEFAULT, OFF, WARN, or ERROR.
Note that the net.ltgt.gradle.errorprone.CheckSeverity needs to be imported into your build scripts (see examples above).