build.gradle

import de.undercouch.gradle.tasks.download.Download
import org.gradle.internal.jvm.Jvm

plugins {
    id 'com.github.johnrengelman.shadow' version '2.0.2'
    id "de.undercouch.download" version "3.3.0"
    id 'java'
    id "net.ltgt.errorprone-base" version "0.0.13"
}
apply plugin: "de.undercouch.download"

repositories {
    jcenter()
    mavenCentral()
}

ext {
    release = false
    assert JavaVersion.current() == JavaVersion.VERSION_1_8: "Set JAVA_HOME to JDK 8. Current version is ${JavaVersion.current()}"

    jsr308 = System.getenv("JSR308") ?: "${rootDir}/../"
    jsr308 = file(jsr308).absolutePath

    annotationTools = "${jsr308}/annotation-tools"
    afu = "${annotationTools}/annotation-file-utilities"
    afuJar = "${afu}/annotation-file-utilities.jar"
    if (!file(afuJar).exists()) {
        println "${afuJar} does not exist"
    }

    stubparser = "${jsr308}/stubparser"
    stubparserJar = "${stubparser}/javaparser-core/target/stubparser.jar"
    if (!file(stubparserJar).exists()) {
        println "${stubparserJar} does not exist"
    }

    jtregHome = "${jsr308}/jtreg"
    formatScriptsHome = "${project(':checker').projectDir}/bin-devel/.run-google-java-format"

    javadocMemberLevel = JavadocMemberLevel.PROTECTED
}

task installGitHooks(type: Copy) {
    description 'Copies git hooks to .git directory'
    from files("checker/bin-devel/git.post-merge", "checker/bin-devel/git.pre-commit")
    rename('git\\.(.*)', '$1')
    into '.git/hooks'
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: "de.undercouch.download"
    apply plugin: 'net.ltgt.errorprone-base'

    group 'org.checkerframework'
    // Increment the minor version rather than just the patch level if:
    //   * any new checkers have been added,\n")
    //   * the patch level is 9 (keep the patch level as a single digit), or\n")
    //   * backward-incompatible changes have been made to APIs or elsewhere.\n")
    version '2.5.2'

    repositories {
        mavenCentral()
    }

    configurations {
        javacJar
        toolsJar
    }

    dependencies {
        javacJar 'org.checkerframework:compiler:2.4.0'
        // Change the JDK via -Dorg.gradle.java.home=JDK_PATH
        toolsJar files(Jvm.current().toolsJar)
    }

    // After all the tasks have been created, modify some of them.
    afterEvaluate {
        // Add the fat checker.jar to the classpath of every Javadoc task. This allows Javadoc in
        // any module to reference classes in any other module.
        // Also, build and use ManualTaglet as a taglet.
        tasks.withType(Javadoc) {
            dependsOn(':checker:shadowJar')
            dependsOn(':util:tagletClasses')
            doFirst {
                options.encoding = 'UTF-8'
                options.memberLevel = javadocMemberLevel
                classpath += files(project(':checker').tasks.getByName('shadowJar').archivePath)
                options.taglets 'org.checkerframework.taglet.ManualTaglet'
                options.tagletPath(project(':util').sourceSets.taglet.output as File[])
                options.links = ['http://docs.oracle.com/javase/8/docs/api/', 'https://docs.oracle.com/javase/8/docs/jdk/api/javac/tree/']
                // This file is looked for by Javadoc.
                file("${destinationDir}/resources/fonts/").mkdirs()
                ant.touch(file: "${destinationDir}/resources/fonts/dejavu.css")
            }
        }

        // Add standard javac options
        tasks.withType(JavaCompile) {
            dependsOn(':installGitHooks')
            sourceCompatibility = 1.8
            targetCompatibility = 1.8
            options.failOnError = true
            options.deprecation = true
            options.compilerArgs += [
                    '-g',
                    // To not get a warning about missing bootstrap classpath for Java 8 (once we use Java 9).
                    "-Xlint:-options",
                    "-Xlint",
            ]
            options.encoding = 'UTF-8'
        }
    }
}

task cloneAndBuildDependencies(type: Exec) {
    description 'Clones (or updates) and builds all dependencies'
    executable './.travis-build-without-test.sh'
    args = ['downloadjdk']
}

task version() {
    description 'Print checker-framework version'
    doLast {
        println version
    }
}
/**
 * Creates a task that runs the checker on the main source set of each subproject. The task is named
 * "check${shortName}".
 * @param projectName name of the project
 * @param checker full qualified name of the checker to run
 * @param shortName shorter version of the checker to use to name the task.
 */
def createCheckTypeTask(projectName, checker, shortName) {
    project("${projectName}").tasks.create(name: "check${shortName}", type: JavaCompile, dependsOn: ':checker:shadowJar') {
        description "Run the ${shortName} Checker on the main sources."
        group 'Verification'
        dependsOn ':jdk8:downloadJdk'
        // Always run the task.
        outputs.upToDateWhen { false }
        source = project("${projectName}").sourceSets.main.java
        classpath = files(project("${projectName}").compileJava.classpath,project(':checker-qual').sourceSets.main.output)
        destinationDir = file("${buildDir}")

        options.annotationProcessorPath = files(project(':checker').tasks.shadowJar.archivePath)
        options.compilerArgs += [
                '-processor', "${checker}",
                '-proc:only',
                '-Xlint:-processing',
                '-AprintErrorStack',
                "-Xbootclasspath/p:${rootDir}/checker/dist/jdk8.jar"
        ]
    }
}
/**
 * Returns a list of all the Java files that should be formatted for the given project. These are:
 *
 * All java files in the main sourceSet.
 * All java files in the tests directory that compile.
 *
 * @param projectName name of the project to format
 * @return a list of all Java files that should be formatted for projectName
 */
List<String> getJavaFilesToFormat(projectName) {
    List<File> javaFiles = new ArrayList<>();
    project(':' + projectName).sourceSets.forEach { set ->
        javaFiles.addAll(set.java.files)
    }
    // Collect all java files in tests directory
    fileTree("${project(projectName).projectDir}/tests").visit { details ->
        if (!details.path.contains("nullness-javac-errors") && details.name.endsWith('java')) {
            javaFiles.add(details.file)
        }
    }
     // Collect all java files in jtreg directory
    fileTree("${project(projectName).projectDir}/jtreg").visit { details ->
        if (!details.path.contains("nullness-javac-errors") && details.name.endsWith('java')) {
            javaFiles.add(details.file)
        }
    }

    List<String> args = new ArrayList<>();
    for (File f : javaFiles) {
        args += f.absolutePath
    }
    return args
}

task htmlValidate(type: Exec) {
    description 'Validate that HTML files are well-formed'
    executable 'html5validator'
    args = [
            "--ignore",
            "/api/",
            "/build/",
            "/docs/manual/manual.html",
            "/checker/jdk/nullness/src/java/lang/ref/package.html"
    ]
}

task allJavadoc(type: Javadoc, group: "Documentation") {
    description = 'Generates a global API documentation for all the modules'
    dependsOn(':checker:shadowJar')
    dependsOn(':util:tagletClasses')
    doLast {
        source(project(':checker').sourceSets.main.allJava, project(':framework').sourceSets.main.allJava,
                project(':dataflow').sourceSets.main.allJava, project(':javacutil').sourceSets.main.allJava)

        classpath = files(subprojects.collect { it.sourceSets.main.compileClasspath })
        destinationDir = file("${projectDir}/docs/api")
        copy {
            from 'docs/logo/Checkmark/CFCheckmark_favicon.png'
            rename('CFCheckmark_favicon.png', 'favicon-checkerframework.png')
            into 'docs/api/'
        }
    }
}

task downloadJtreg(type: Download) {
    description "Downloads and unpacks jtreg."
    onlyIf { !(new File("${jtregHome}/lib/jtreg.jar").exists()) }
    src 'https://ci.adoptopenjdk.net/view/Dependencies/job/jtreg/lastSuccessfulBuild/artifact/jtreg-4.2.0-tip.tar.gz'
    overwrite true
    dest new File(buildDir, 'jtreg-4.2.0-tip.tar.gz')
    doLast {
        copy {
            from tarTree(dest)
            into "${jtregHome}/.."
        }
        exec {
            commandLine('chmod',  '+x', "${jtregHome}/bin/jtdiff", "${jtregHome}/bin/jtreg")
        }
    }
}

task getCodeFormatScripts() {
    description 'Obtain or update the run-google-java-format scripts'
    if (file(formatScriptsHome).exists()) {
        exec {
            workingDir formatScriptsHome
            executable 'git'
            args = ['pull', '-q']
            ignoreExitValue = true
        }
    } else {
        exec {
            workingDir "${formatScriptsHome}/../"
            executable 'git'
            args = ['clone', '-q', 'https://github.com/plume-lib/run-google-java-format.git', '.run-google-java-format']
        }
    }
}

task tags {
    description 'Create Emacs TAGS table'
    doLast {
        exec {
            commandLine "etags", "-i", "checker/TAGS", "-i", "dataflow/TAGS", "-i", "framework/TAGS", "-i", "javacutil/TAGS", "-i", "util/TAGS", "-i", "docs/manual/TAGS"
        }
        exec {
            commandLine "make", "-C", "docs/manual", "tags"
        }
    }
}

subprojects {
    configurations {
        errorprone
    }

    dependencies {
        errorprone group: 'com.google.errorprone', name: 'error_prone_ant', version: '2.2.0'
    }

    task checkFormat(type: Exec, dependsOn: getCodeFormatScripts, group: 'Format') {
        description 'Check whether the source code is properly formatted'
        // jdk8 and checker-qual have no source, so skip
        onlyIf { !project.name.is('jdk8') && !project.name.is('checker-qual') }
        executable 'python'

        doFirst {
            args+= "${formatScriptsHome}/check-google-java-format.py"
            args += "--aosp" // 4 space indentation
            args += getJavaFilesToFormat(project.name)
        }
        ignoreExitValue = true
        doLast {
            if (execResult.exitValue != 0) {
                throw new RuntimeException('Found improper formatting, try running:  gradle reformat"')
            }
        }
    }

    task reformat(type: Exec, dependsOn: getCodeFormatScripts, group: 'Format') {
        description 'Format the Java source code'
        // jdk8 and checker-qual have no source, so skip
        onlyIf { !project.name.is('jdk8') && !project.name.is('checker-qual') }
        executable 'python'
        doFirst {
            args += "${formatScriptsHome}/run-google-java-format.py"
            args += "--aosp" // 4 space indentation
            args += getJavaFilesToFormat(project.name)
        }
    }

    shadowJar {
        // Relocate packages that might conflict with users classpath.
        doFirst {
            if (release) {
                // Only relocate JavaParser during a release:
                relocate 'com.github.javaparser', 'org.checkerframework.com.github.javaparser'
            }
        }
        // Don't relocate javac.jar:
        // relocate 'com.sun', 'org.checkeframework.com.sun'
        // relocate 'javax','org.checkerframework.javax'
        // relocate 'jdk', 'org.checkerframework.jdk'

        // These appear in annotation-file-utilities.jar:
        relocate 'org.apache', 'org.checkerframework.org.apache'
        relocate 'org.relaxng', 'org.checkerframework.org.relaxng'
        relocate 'org.plumelib', 'org.checkerframework.org.plumelib'
        // relocate 'sun', 'org.checkerframework.sun'
        relocate 'org.objectweb.asm', 'org.checkerframework.org.objectweb.asm'
        relocate 'com.google', 'org.checkerframework.com.google'
        relocate 'plume', 'org.checkerframework.plume'
    }

    if (!project.name.is('checker-qual') && !project.name.is('jdk8')) {
        task tags(type: Exec) {
            description 'Create Emacs TAGS table'
            commandLine "bash", "-c", "find . \\( -name jdk \\) -prune -o -name '*.java' -print | sort-directory-order | xargs ctags -e -f TAGS"
        }
    }

    // Things in this block reference definitions in the subproject that do not exist,
    // until the project is evaluated.
    afterEvaluate {
        // Create a sourcesJar task for each subproject
        tasks.create(name: 'sourcesJar', type: Jar) {
            description 'Creates sources jar.'
            classifier = 'source'
            baseName = jar.baseName
            from sourceSets.main.java
        }

        // Create a javadocJar task for each subproject
        tasks.create(name: 'javadocJar', type: Jar, dependsOn: 'javadoc') {
            description 'Creates javadoc jar.'
            classifier = 'javadoc'
            baseName = jar.baseName
            from tasks.javadoc.destinationDir
        }

        // Adds manifest to all Jar files
        tasks.withType(Jar) {
            includeEmptyDirs = false
            manifest {
                attributes("Implementation-Version": "${version}")
                attributes("Implementation-URL": "https://checkerframework.org")
            }
        }

        // Add tasks to run various checkers on all the main source sets.
        createCheckTypeTask(project.name, 'org.checkerframework.checker.nullness.NullnessChecker', 'Nullness')
        createCheckTypeTask(project.name, 'org.checkerframework.framework.util.PurityChecker', 'Purity')

        // Add jtregTests to framework and checker modules
        if (project.name.is('framework') || project.name.is('checker')) {
            tasks.create(name: 'jtregTests', dependsOn: ':downloadJtreg', group: 'Verification') {
                description 'Run the jtreg tests.'
                dependsOn('compileJava')
                dependsOn('compileTestJava')
                dependsOn(':jdk8:downloadJdk')
                dependsOn('shadowJar')

                String jtregOutput = "${buildDir}/jtreg"
                String name = 'all'
                String tests = '.'
                doLast {
                    exec {
                        executable "${jtregHome}/bin/jtreg"
                        args = [
                                "-dir:${projectDir}/jtreg",
                                "-workDir:${jtregOutput}/${name}/work",
                                "-reportDir:${jtregOutput}/${name}/report",
                                "-verbose:summary",
                                "-javacoptions:-g",
                                "-keywords:!ignore",
                                '-samevm',
                                // Required for checker/jtreg/nullness/PersistUtil.java and other tests
                                // Must use langtools javap.jar rather than tools.jar because the
                                // tools.jar in the docker vm doesn't have the required classes.
                                "-vmoptions:-Xbootclasspath/p:${jsr308}/jsr308-langtools/dist/lib/javac.jar:" +
                                        "${jsr308}/jsr308-langtools/dist/lib/javap.jar:" +
                                        "${tasks.shadowJar.archivePath}:${sourceSets.test.output.asPath}",

                                "-javacoptions:-Xbootclasspath/p:${projectDir}/dist/jdk8.jar:" +
                                        "${jsr308}/jsr308-langtools/dist/lib/javac.jar",
                        ]
                        if (project.name.is('checker')) {
                            args += [
                                    "-javacoptions:-Xbootclasspath/p:${projectDir}/dist/jdk8.jar",
                            ]
                        }

                        // Location of jtreg tests
                        args += "${tests}"
                    }
                }
            }
        }

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

        // Configure JUnit tests
        tasks.withType(Test) {
            if (project.name.is('checker')) {
                dependsOn('copyJarsToDist')
                systemProperties += [JDK_JAR: "${projectDir}/dist/jdk8.jar"]
            }

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

            testLogging {
                showStandardStreams = true
                // Always run the tests
                outputs.upToDateWhen { false }

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

            // 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"
                }

            }
        }

        // Create a runErrorProne task.
        tasks.create(name: 'runErrorProne', type: JavaCompile, group: 'Verification') {
            description 'Run the error-prone compiler on the main sources'
            toolChain net.ltgt.gradle.errorprone.ErrorProneToolChain.create(project)
            source = sourceSets.main.java.asFileTree
            classpath = sourceSets.main.compileClasspath.asFileTree
            destinationDir = new File("${buildDir}", 'errorprone')

            options.compilerArgs = [
                    // Many compiler classes are interned.
                    '-Xep:ReferenceEquality:OFF',
                    // These might be worth fixing.
                    '-Xep:DefaultCharset:OFF',
                    // Not useful to suggest Splitter; maybe clean up.
                    '-Xep:StringSplitter:OFF',
                    '-Werror',
            ]
        }

        // Create an allTests task
        tasks.create(name: 'allTests', type: GradleBuild, group: 'Verification') {
            description 'Run all Checker Framework tests'
            tasks = ['test', 'checkPurity']
            if (project.name.is('framework') || project.name.is('checker')) {
                tasks += ['checkCompilerMessages', 'jtregTests']
            }
            if (projects.name.is('framework')) {
                tasks += ['wholeProgramInferenceTests', 'loaderTests']
            }

            if (project.name.is('checker')) {
                tasks += ['nullnessExtraTests', 'commandLineTests', 'tutorialTests']
            }
        }

        task javadocPrivate(dependsOn: javadoc) {
            doFirst {
                javadocMemberLevel = JavadocMemberLevel.PRIVATE
            }
            doLast {
                javadocMemberLevel = JavadocMemberLevel.PROTECTED
            }
        }
    }
}

assemble.dependsOn(':checker:copyJarsToDist')

task checkStyle(group: 'Format') {
    description 'Check basic style guidelines'
    String[] ignoreDirectories = ['.git',
                                  '.gradle',
                                  '.idea',
                                  'annotated',
                                  'api',
                                  'bib',
                                  'bootstrap',
                                  'build',
                                  'jdk',
                                  'maven-artifacts']

    String[] ignoreFilePatterns = [
            '*.aux',
            '*.bib',
            '*.class',
            '*.dvi',
            '*.expected',
            '*.gif',
            '*.jar',
            '*.jtr',
            '*.log',
            '*.out',
            '*.patch',
            '*.pdf',
            '*.png',
            '*.sty',
            '*.xcf',
            '*~',
            '#*#',
            'CFLogo.ai',
            'logfile.log.rec.index',
            'manual.html',
            'manual.html-e',
            'junit.*.properties']
    doLast {
        FileTree tree = fileTree(dir: projectDir)
        for (String dir : ignoreDirectories) {
            tree.exclude "**/${dir}/**"
        }
        for (String file : ignoreFilePatterns) {
            tree.exclude "**/${file}"
        }
        boolean failed = false
        tree.visit {
            if (!it.file.isDirectory()) {
                int isBlankLine
                it.file.eachLine { line ->
                    if (line.endsWith(' ')) {
                        println("Trailing whitespace: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (!line.startsWith('\\') &&
                            (line.matches('^.* (else|finally|try)\\{}.*$')
                                    || line.matches('^.*}(catch|else|finally) .*$')
                                    || line.matches('^.* (catch|for|if|while)\\('))) {
                        // This runs on non-java files, too.
                        println("Missing space: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (line.isEmpty()) {
                        isBlankLine++;
                    } else {
                        isBlankLine = 0;
                    }
                }

                if (isBlankLine > 1) {
                    println("Blank line at end of file: ${it.file.absolutePath}")
                    failed = true
                }

                RandomAccessFile file
                try {
                    file = new RandomAccessFile(it.file, 'r')
                    int end = file.length() - 1;
                    if (end > 0) {
                        file.seek(end)
                        byte last = file.readByte()
                        if (last != '\n') {
                            println("Missing newline at end of file: ${it.file.absolutePath}")
                            failed = true
                        }
                    }
                } finally {
                    if (file != null) {
                        file.close()
                    }
                }
            }
        }
        if (failed) {
            throw new GradleException("Files do not meet basic style guidelines.")
        }
    }
}

task releaseBuild(type: GradleBuild) {
    description 'Build everything required for a release'
    startParameter = new StartParameter()
    startParameter.setProjectProperties(release: true)
    // This downloads rather than builds the jdk8.jar because that's what is used in all the Travis tests.
    tasks = ['clean', 'assemble', 'sourcesJar', 'javadocJar', 'allJavadoc', ':checker-qual:compatQualSourcesJar', ':checker-qual:compatQualJavadocJar']
}
task releaseAndTest(type: GradleBuild, dependsOn: 'releaseBuild') {
    description 'Build everything required for a release and runn allTests'
    startParameter = new StartParameter()
    startParameter.setProjectProperties(release: true)
    tasks = ['allTests']
}