xref: /aosp_15_r20/external/nullaway/nullaway/build.gradle (revision f50c306653bc89b8210ce6c9e0b0b44fc134bc03)

/*
 * Copyright (C) 2017. Uber Technologies
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import net.ltgt.gradle.errorprone.CheckSeverity

plugins {
    id 'java-library'
    id 'nullaway.java-test-conventions'
}

configurations {
    // A configuration holding the jars for the oldest supported version of Error Prone, to use with tests
    errorProneOldest
}

dependencies {
    compileOnly project(":annotations")
    compileOnly deps.apt.autoValueAnnot
    annotationProcessor deps.apt.autoValue
    compileOnly deps.apt.autoServiceAnnot
    annotationProcessor deps.apt.autoService
    compileOnly deps.build.jsr305Annotations
    compileOnly deps.test.jetbrainsAnnotations
    compileOnly deps.apt.javaxInject


    compileOnly deps.build.errorProneCheckApi
    implementation deps.build.checkerDataflow
    implementation deps.build.guava

    testImplementation project(":annotations")
    testImplementation deps.test.junit4
    testImplementation(deps.build.errorProneTestHelpers) {
        exclude group: "junit", module: "junit"
    }
    testImplementation deps.test.jetbrainsAnnotations
    testImplementation deps.test.junit5Jupiter
    testImplementation deps.test.cfQual
    testImplementation deps.test.cfCompatQual
    testImplementation deps.build.jspecify
    testImplementation project(":test-java-lib")
    testImplementation deps.apt.jakartaInject
    testImplementation deps.apt.javaxInject
    testImplementation deps.test.rxjava2
    testImplementation deps.test.commonsLang
    testImplementation deps.test.commonsLang3
    testImplementation project(":test-library-models")
    testImplementation deps.test.lombok
    testImplementation deps.test.springBeans
    testImplementation deps.test.springContext
    testImplementation deps.test.grpcCore
    testImplementation project(":test-java-lib-lombok")
    testImplementation deps.test.mockito
    testImplementation deps.test.javaxAnnotationApi
    testImplementation deps.test.assertJ
    // This is for a test exposing a CFG construction failure in the Checker Framework.  We can probably remove it once
    // the issue is fixed upstream and we update. See https://github.com/typetools/checker-framework/issues/6396.
    testImplementation 'org.apache.spark:spark-sql_2.12:3.3.2'

    errorProneOldest deps.build.errorProneCheckApiOld
    errorProneOldest(deps.build.errorProneTestHelpersOld) {
        exclude group: "junit", module: "junit"
    }
}

javadoc {
    failOnError = false
}

apply plugin: 'com.vanniktech.maven.publish'

// These --add-exports arguments are required when targeting JDK 11+ since Error Prone and NullAway access a bunch of
// JDK-internal APIs that are not exposed otherwise.  Since we currently target JDK 8, we do not need to pass the
// arguments, as encapsulation of JDK internals is not enforced on JDK 8.  In fact, the arguments cause a compiler error
// when targeting JDK 8.  Leaving commented so we can easily add them back once we target JDK 11.
//    tasks.withType(JavaCompile).configureEach {
//        options.compilerArgs += [
//                "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
//                "--add-exports=jdk.compiler/com.sun.source.tree=ALL-UNNAMED",
//        ]
//    }

// Create a task to test on JDK 8
// NOTE: even when we drop JDK 8 support, we will still need a test task similar to this one for testing building
// against a recent JDK and Error Prone version but then running on the oldest supported JDK and Error Prone version,
// to check for binary compatibility issues.
def jdk8Test = tasks.register("testJdk8", Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(8)
    }

    description = "Runs the test suite on JDK 8"
    group = LifecycleBasePlugin.VERIFICATION_GROUP

    // Copy inputs from normal Test task.
    def testTask = tasks.getByName("test")
    // A bit of a hack: we add the dependencies of the oldest supported Error Prone version to the _beginning_ of the
    // classpath, so that they are used instead of the latest version.  This exercises the scenario of building
    // NullAway against the latest supported Error Prone version but then running on the oldest supported version.
    classpath = configurations.errorProneOldest + testTask.classpath

    testClassesDirs = testTask.testClassesDirs
    jvmArgs "-Xbootclasspath/p:${configurations.errorproneJavac.asPath}"
    filter {
        // JDK 8 does not support diamonds on anonymous classes
        excludeTestsMatching "com.uber.nullaway.NullAwayJSpecifyGenericsTests.overrideDiamondAnonymousClass"
        // tests cannot run on JDK 8 since Mockito version no longer supports it
        excludeTestsMatching "com.uber.nullaway.NullAwaySerializationTest.initializationError"
        excludeTestsMatching "com.uber.nullaway.handlers.contract.ContractUtilsTest.getEmptyAntecedent"
    }
}

tasks.named('check').configure {
    dependsOn(jdk8Test)
}

// Create a task to build NullAway with NullAway checking enabled
tasks.register('buildWithNullAway', JavaCompile) {
    onlyIf {
        // We only do NullAway checks when compiling against the latest
        // version of Error Prone (as nullability annotations on the APIs
        // can change between versions)
        deps.versions.errorProneApi == deps.versions.errorProneLatest
    }
    // Configure compilation to run with Error Prone and NullAway
    source = sourceSets.main.java
    classpath = sourceSets.main.compileClasspath
    destinationDirectory = file("$buildDir/ignoredClasses")
    options.annotationProcessorPath = files(
            configurations.errorprone.asCollection(),
            sourceSets.main.annotationProcessorPath,
            // This refers to the NullAway jar built from the current source
            jar.archiveFile.get(),
            sourceSets.main.compileClasspath)
    options.errorprone.enabled = true
    options.errorprone {
        option("NullAway:AnnotatedPackages", "com.uber,org.checkerframework.nullaway,com.google.common")
        option("NullAway:CastToNonNullMethod", "com.uber.nullaway.NullabilityUtil.castToNonNull")
        option("NullAway:CheckOptionalEmptiness")
        option("NullAway:AcknowledgeRestrictiveAnnotations")
        option("NullAway:CheckContracts")
        option("NullAway:JSpecifyMode")
    }
    // Make sure the jar has already been built
    dependsOn 'jar'
    // Check that the NullAway jar actually exists (without this,
    // Gradle will run the compilation even if the jar doesn't exist)
    doFirst {
        assert jar.archiveFile.get().getAsFile().exists()
    }
}

project.tasks.named('check').configure {
    dependsOn 'buildWithNullAway'
}