build.gradle

buildscript {
    dependencies {
        if (JavaVersion.current() >= JavaVersion.VERSION_11) {
            // Code formatting; defines targets "spotlessApply" and "spotlessCheck".
            // https://github.com/diffplug/spotless/tags ; see tags starting "gradle/"
            // Only works on JDK 11+.
            classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.22.0'
        }
    }
}

plugins {
    id 'com.github.johnrengelman.shadow' version '7.1.2'
}

apply plugin: 'java'

// Note:  For this setup to work you must follow the instructions outlined in the
//       checker manual Section 25.3 "Building from Source"
// http://types.cs.washington.edu/checker-framework/current/checkers-manual.html#build-source

ext {
    jsr308 = System.getenv('JSR308') ?: file(new File("..")).absolutePath
    checkerFrameworkPath = System.getenv('CHECKERFRAMEWORK') ?: "${jsr308}/checker-framework"
    checkerJar = "${checkerFrameworkPath}/checker/dist/checker.jar"
    afu = "${jsr308}/annotation-tools/annotation-file-utilities"
    lingelingTar = "${projectDir}/lib/lingeling.tar.gz"
    dljcScript = "${jsr308}/do-like-javac/dljc"

    // On a Java 8 JVM, use error-prone javac and source/target 8.
    // On a Java 9+ JVM, use the host javac, default source/target, and required module flags.
    isJava8 = JavaVersion.current() == JavaVersion.VERSION_1_8
    isJava11plus = JavaVersion.current() >= JavaVersion.VERSION_11
    errorproneJavacVersion = '9+181-r4173-1'

    // Keep in sync with checker-framework/build.gradle.
    // TODO: find a way to directly use that variable.
    compilerArgsForRunningCF = [
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
        "--add-exports",
        "jdk.compiler/com.sun.tools.javac.file=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.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-opens",
        "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
    ]
    if (isJava11plus) {
        apply plugin: 'com.diffplug.spotless'
        spotless {
            format 'misc', {
                target '*.md', '*.tex', '.gitignore', 'Makefile'
                indentWithSpaces(2)
                trimTrailingWhitespace()
            }

            java {
                googleJavaFormat().aosp()
                importOrder('com', 'jdk', 'lib', 'lombok', 'org', 'java', 'javax')
                formatAnnotations().addTypeAnnotation("PolyInitialized")
            }

            groovyGradle {
                target '**/*.gradle'
                greclipse()  // which formatter Spotless should use to format .gradle files.
                indentWithSpaces(4)
                trimTrailingWhitespace()
            }
        }
    }
}

println '===================================='
println '    Checker Framework Inference     '
println '===================================='
println ''
println '-------------------------------'
println 'Important Environment Variables'
println '-------------------------------'
println 'CHECKERFRAMEWORK: ' + checkerFrameworkPath

repositories {
    mavenCentral()
}

configurations {
    javacJar
}

dependencies {
    if (isJava8) {
        javacJar group: 'com.google.errorprone', name: 'javac', version: "$errorproneJavacVersion"
    }

    implementation files("${checkerJar}")
    implementation group: 'com.google.errorprone', name: 'javac', version: "$errorproneJavacVersion"

    implementation 'org.plumelib:options:1.0.5'
    implementation 'org.plumelib:plume-util:1.8.1'

    implementation 'com.google.guava:guava:31.1-jre'

    // AFU is an "includedBuild" imported in settings.gradle, so the version number doesn't matter.
    // https://docs.gradle.org/current/userguide/composite_builds.html#settings_defined_composite
    implementation('io.github.eisop:annotation-file-utilities:*') {
        exclude group: 'com.google.errorprone', module: 'javac'
    }

    // Serialize constraints
    implementation 'com.googlecode.json-simple:json-simple:1.1.1'
    // Pretty print serialized constraints
    implementation 'com.google.code.gson:gson:2.9.1'

    implementation 'org.ow2.sat4j:org.ow2.sat4j.core:2.3.6'
    implementation 'org.ow2.sat4j:org.ow2.sat4j.maxsat:2.3.6'

    implementation 'tools.aqua:z3-turnkey:4.11.2'

    testImplementation fileTree(dir: "${checkerFrameworkPath}/framework-test/build/libs", include: "framework-test-*.jar")
    // Mocking library. Used in a couple tests
    testImplementation 'org.mockito:mockito-all:2.0.2-beta'
    testImplementation 'junit:junit:4.13.2'
}

sourceSets {
    main {
        java {
            srcDirs = ["src"]
        }

        resources {
            srcDir "src"
            include "**/*.astub"
        }
    }

    test {
        java {
            srcDirs = ["tests"]
        }
    }
}

task buildLingeling(type: Exec) {
    description 'Build Lingeling solver'
    onlyIf { !(new File(lingelingTar).exists()) }
    workingDir './scripts'
    commandLine './buildLingeling'
}

task buildDLJC(type: Exec) {
    description 'Build DLJC Tool'
    onlyIf { !(new File(dljcScript).exists()) }
    workingDir './scripts'
    commandLine './buildDLJC'
}

test {
    dependsOn(shadowJar)
    dependsOn('dist')

    systemProperties 'path.afu.scripts': "${afu}/scripts",
    'use.hacks': true

    systemProperties += [JDK_JAR: "${checkerFrameworkPath}/checker/dist/jdk8.jar"]

    if (project.hasProperty('emit.test.debug')) {
        systemProperties += ["emit.test.debug": 'true']
    }

    if (isJava8) {
        jvmArgs += [
            "-Xbootclasspath/p:${configurations.javacJar.asPath}"
        ]
    } else {
        // Without this, the test throw "java.lang.OutOfMemoryError: Java heap space"
        // Corresponding pull request: https://github.com/opprop/checker-framework-inference/pull/263
        forkEvery(1)
        jvmArgs += compilerArgsForRunningCF
    }

    testLogging {
        // Always run the tests
        outputs.upToDateWhen { false }
        // The following prints out each time a test is passed.
        // events "passed", "skipped", "failed", "standardOut", "standardError"

        // Show the found unexpected diagnostics and expected diagnostics not found.
        exceptionFormat "full"
    }

    // After each test, print a summary.
    afterSuite { desc, result ->
        if (desc.getClassName() != null) {
            long mils = result.getEndTime() - result.getStartTime()
            double seconds = mils / 1000.0

            println "Testsuite: ${desc.getClassName()}\n" +
                    "Tests run: ${result.testCount}, " +
                    "Failures: ${result.failedTestCount}, " +
                    "Skipped: ${result.skippedTestCount}, " +
                    "Time elapsed: ${seconds} sec\n"
        }
    }
}

compileJava {
    dependsOn(buildLingeling)
    dependsOn(buildDLJC)
    options.compilerArgs = [
        '-implicit:class',
        '-Awarns',
        '-Xmaxwarns',
        '10000',
        // Can't use this because JSON library contains raw types:
        // '-Xlint:unchecked',
        '-Xlint:deprecation',
        '-Werror',
    ]
}

// Exclude parts of the build directory that don't include classes from being packaged in
// the jar file.
// IMPORTANT: If "libs" is packaged in the JAR file you end up with an infinitely
// recursive jar task that will fill up your hard drive (eventually)
jar {
    description = 'Makes a jar with ONLY the classes compiled for checker ' +
            'framework inference and NONE of its dependencies'
    archiveFileName = "checker-framework-inference.jar"
    manifest.attributes("Main-Class": "checkers.inference.InferenceLauncher")
    exclude("dependency-cache", "libs", "tmp")
}

shadowJar {
    dependencies {
        exclude(dependency("junit:.*:.*"))
    }
    description 'Creates the "fat" checker.jar in dist'
    destinationDirectory = file("${projectDir}/dist")
    archiveFileName = "checker-framework-inference.jar"
}

task dist(dependsOn: shadowJar, type: Copy) {
    description = "If your Checker Framework project is fully built, this task " +
            "will build checker-framework-inference.jar, copy all the relevant runtime jars into " +
            "the dist directory."
    from files(
            "${checkerFrameworkPath}/checker/dist/checker.jar",
            "${checkerFrameworkPath}/checker/dist/checker-qual.jar",
            "${checkerFrameworkPath}/checker/dist/checker-util.jar",
            "${checkerFrameworkPath}/checker/dist/javac.jar",
            )
    into file('dist')
}

task dependenciesJar(dependsOn: dist, type: Jar) {
    description 'Create a jar file with all the dependencies.'
    duplicatesStrategy DuplicatesStrategy.EXCLUDE
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
    archiveFileName = 'dependencies.jar'
    destinationDirectory = file("${projectDir}/dist/")
}

task testLibJar(dependsOn: dist, type: Jar) {
    from sourceSets.test.output.classesDirs
    include ('checkers/inference/test/**')
    archiveFileName = 'inference-framework-test-lib.jar'
    destinationDirectory = file("${projectDir}/dist/")
}

tasks.clean {
    delete += "build/libs/checker-framework-inference.zip"
    delete += "jdk8.jar"
    delete += "javac.jar"
    delete += fileTree('dist') {
        include '**/*.jar'
    }
    delete += "testdata/tmp"
}


task release(type: Zip) {
    from('src') {
        into('release/src')
    }

    from('dist') {
        into('release/dist')
    }
    from('scripts') {
        into('release/scripts')
        include '*.py'
    }

    archiveBaseName = 'release'
}

task cloneAndBuildDependencies(type: Exec) {
    description 'Clones (or updates) and builds all dependencies'
    executable './.ci-build-without-test.sh'
}

task testCheckerInferenceScript(type: Exec, dependsOn: dist) {
    description 'Basic sanity check of scripts/inference'
    executable './scripts/inference'
    args = [
        '--mode',
        'TYPECHECK',
        '--checker',
        'ostrusted.OsTrustedChecker',
        '--solver',
        'checkers.inference.solver.PropagationSolver',
        'testdata/ostrusted/Test.java'
    ]
}

task testCheckerInferenceDevScript(type: Exec, dependsOn: [dist, dependenciesJar]) {
    description 'Basic sanity check of scripts/inference-dev'
    executable './scripts/inference-dev'
    args = [
        '--mode',
        'INFER',
        '--checker',
        'interning.InterningChecker',
        '--solver',
        'checkers.inference.solver.MaxSat2TypeSolver',
        '--hacks=true',
        'testdata/interning/MapAssignment.java'
    ]
}

task testDataflowExternalSolvers(type: Exec, dependsOn: [dist, dependenciesJar]) {
    description 'Test Dataflow type system on its external solvers Lingeling and LogicBlox'
    executable './testing/dataflowexample/ci-test.sh'
}

afterEvaluate {
    // Create a task for each test class whose name is the same as the class name.
    sourceSets.test.java.filter {
        it.path.contains('tests/checkers') &&
                it.path.endsWith('Test.java') &&
                !it.path.contains('CFInferenceTest')
    }.forEach { file ->
        String junitClassName = file.name.replaceAll(".java", "")
        tasks.create(name: "${junitClassName}", type: Test, group: 'Verification') {
            description "Run ${junitClassName} tests."
            include "**/${name}.class"
        }
    }

    // Configure Tests
    tasks.withType(Test) {
        dependsOn(shadowJar)

        systemProperties 'path.afu.scripts': "${afu}/scripts",
        'path.inference.script': "${projectDir}/scripts/inference",
        'use.hacks': true,
        JDK_JAR: "${checkerFrameworkPath}/checker/dist/jdk8.jar"

        if (project.hasProperty('emit.test.debug')) {
            systemProperties += ["emit.test.debug": 'true']
        }

        if (isJava8) {
            jvmArgs += [
                "-Xbootclasspath/p:${configurations.javacJar.asPath}"
            ]
        }

        testLogging {
            // Always run the tests
            outputs.upToDateWhen { false }
            // The following prints out each time a test is passed.
            // events "passed", "skipped", "failed", "standardOut", "standardError"
            events "failed"
            // Show the found unexpected diagnostics and expected diagnostics not found.
            exceptionFormat "full"
        }

        // After each test, print a summary.
        afterSuite { desc, result ->
            if (desc.getClassName() != null) {
                long mils = result.getEndTime() - result.getStartTime()
                double seconds = mils / 1000.0

                println "Testsuite: ${desc.getClassName()}\n" +
                        "Tests run: ${result.testCount}, " +
                        "Failures: ${result.failedTestCount}, " +
                        "Skipped: ${result.skippedTestCount}, " +
                        "Time elapsed: ${seconds} sec\n"
            }
        }
    }
}

/// Commented out because plugins section is commented out
// /* Configuration for formatting */
// googleJavaFormat {
//   // toolVersion '1.3'
//   options style: 'AOSP'
// }
// tasks.googleJavaFormat {
//   group 'Formatting'
//   description = "Reformat Java source code with Google-Java-format"
//   exclude 'testing'
//   exclude 'testinputs'
// }
// tasks.verifyGoogleJavaFormat {
//   group 'Formatting'
//   description = "Check Java source code is in Google-Java-format"
//   exclude 'testing'
//   exclude 'testinputs'
// }

task etags {
    doLast {
        def sources = (sourceSets.main.java).getFiles().collect({ src -> src.getPath() }).sort()
        def sourcesStr = sources.inject(null, { acc, source -> acc ? acc + " " + source : source })

        def proc = "etags ${sourcesStr} ".execute()
        proc.in.eachLine { line -> println line }
        proc.err.eachLine { line -> println 'ERROR: ' + line }
        proc.waitFor()
    }
}

task tags(dependsOn: etags)

task countHacks(type: Exec) {
    commandLine "bash", "-c", "grep -r 'InferenceMain.isHackMode(' src/ | wc -l"
}