build.gradle

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

plugins {
    // https://plugins.gradle.org/plugin/com.github.johnrengelman.shadow (v5 requires Gradle 5)
    id 'com.github.johnrengelman.shadow' version '4.0.4'
    // https://plugins.gradle.org/plugin/de.undercouch.download
    id "de.undercouch.download" version "3.4.3"
    id 'java'
    // TODO: Migrate to newer version: https://github.com/tbroyer/gradle-errorprone-plugin#migration-from-versions-00x
    id "net.ltgt.errorprone-base" version "0.0.13"
    // https://plugins.gradle.org/plugin/org.ajoberstar.grgit
    id 'org.ajoberstar.grgit' version '3.0.0' apply false
}
apply plugin: "de.undercouch.download"

import org.ajoberstar.grgit.Grgit

repositories {
    jcenter()
    mavenCentral()
}

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

    parentDir = file("${rootDir}/../").absolutePath

    annotationTools = "${parentDir}/annotation-tools"
    afu = "${annotationTools}/annotation-file-utilities"
    afuJar = "${afu}/annotation-file-utilities-all.jar"

    stubparser = "${parentDir}/stubparser"
    stubparserJar = "${stubparser}/javaparser-core/target/stubparser.jar"

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

    javadocMemberLevel = JavadocMemberLevel.PROTECTED

    // The local git repository, typically in the .git directory, but not for worktrees.
    // This value is always overwritten, but Gradle needs the variable to be initialized.
    localRepo = ".git"
}

task setLocalRepo(type:Exec) {
    commandLine 'git', 'worktree', 'list'
    standardOutput = new ByteArrayOutputStream()
    doLast {
       String worktreeList = standardOutput.toString()
       localRepo = worktreeList.substring(0, worktreeList.indexOf(" ")) + "/.git"
    }
}

task installGitHooks(type: Copy, dependsOn: 'setLocalRepo') {
    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 localRepo + "/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,
    //   * the patch level is 9 (keep the patch level as a single digit), or
    //   * backward-incompatible changes have been made to APIs or elsewhere.
    version '2.7.0'

    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(':framework-test: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(':framework-test').sourceSets.taglet.output as File[])
                options.links = ['https://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}", for example "checkPurity" or "checkNullness".
 * @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 ':checker:updateJdk'
        // 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',
                "-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, group: 'Format') {
    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"
    ]
}


// `gradle allJavadoc` builds the Javadoc for all modules in `docs/api`.
//   This is what is published to checkerframework.org.
// `gradle javadoc` builds the Javadoc for each sub-project in <subproject>/build/docs/javadoc/ .
//   It's needed to create the Javadoc jars that we release in Maven Central.
// To make javadoc for only one subproject, run `./gradlew javadoc`
//   in the subproject or `./gradlew :checker:javadoc` at the top level.
task allJavadoc(type: Javadoc, group: "Documentation") {
    description = 'Generates a global API documentation for all the modules'
    dependsOn(':checker:shadowJar')
    dependsOn(':framework-test:tagletClasses')
    destinationDir = file("${rootDir}/docs/api")
    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 })
    doLast {
        copy {
            from 'docs/logo/Checkmark/CFCheckmark_favicon.png'
            rename('CFCheckmark_favicon.png', 'favicon-checkerframework.png')
            into "${rootDir}/docs/api"
        }
    }
}

// See documentation for allJavadoc task.
javadoc.dependsOn(allJavadoc)

configurations {
    requireJavadoc
}
dependencies {
    // https://mvnrepository.com/artifact/org.plumelib/require-javadoc
    compile group: 'org.plumelib', name: 'require-javadoc', version: '0.1.0'
}
task requireJavadoc(type: Javadoc, group: "Documentation") {
    description = 'Ensures that Java elements have Javadoc documentation.'
    destinationDir = file("${rootDir}/docs/api")
    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.deleteDir()

    // options.memberLevel = JavadocMemberLevel.PRIVATE
    options.docletpath = project.sourceSets.main.compileClasspath as List
    options.doclet = "org.plumelib.javadoc.RequireJavadoc"
    // options.addStringOption('skip', 'ClassNotToCheck|OtherClass')
}
task requireJavadocPrivate(type: Javadoc, group: "Documentation") {
    description = 'Ensures that all (even private) Java elements have Javadoc documentation.'
    destinationDir = file("${rootDir}/docs/api")
    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.deleteDir()

    options.memberLevel = JavadocMemberLevel.PRIVATE
    options.docletpath = project.sourceSets.main.compileClasspath as List
    options.doclet = "org.plumelib.javadoc.RequireJavadoc"
    // options.addStringOption('skip', 'ClassNotToCheck|OtherClass')
}

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

// See alternate implementation getCodeFormatScriptsInGradle below.
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']
        }
    }
}

// This implementation is preferable to the above because it does work in Gradle rather than in bash.
// However, it fails in the presence of worktrees: https://github.com/ajoberstar/grgit/issues/97
task getCodeFormatScriptsInGradle {
  description "Obtain the run-google-java-format scripts"
  doLast {
    if (! new File(formatScriptsHome).exists()) {
      def rgjfGit = Grgit.clone(dir: formatScriptsHome, uri: 'https://github.com/plume-lib/run-google-java-format.git')
    } else {
      def rgjfGit = Grgit.open(dir: formatScriptsHome)
      rgjfGit.pull()
    }
  }
}

task pythonIsInstalled(type: Exec) {
  description "Check that the python executable is installed."
  executable = "python"
  args "--version"
}

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

subprojects {
    configurations {
        errorprone
    }

    dependencies {
        // https://mvnrepository.com/artifact/com.google.errorprone/error_prone_core
	// If you update this:
	//  * Temporarily comment out "-Werror" elsewhere in this file
	//  * Repeatedly run `./gradlew clean runErrorProne` and fix all errors
	//  * Uncomment "-Werror"
        errorprone group: 'com.google.errorprone', name: 'error_prone_core', version: '2.3.3'
    }

    task checkFormat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], 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.startsWith('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:  ./gradlew reformat"')
            }
        }
    }

    task reformat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], group: 'Format') {
        description 'Format the Java source code'
        // jdk8 and checker-qual have no source, so skip
        onlyIf { !project.name.is('jdk8') && !project.name.startsWith('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 user's 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-all.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.startsWith('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")
                attributes('Automatic-Module-Name': "org.checkerframework." + project.name.replaceAll('-', '.'))
            }
        }

        // 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(':checker:updateJdk')
                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:${configurations.javacJar.asPath}:" +
                                        "${parentDir}/jsr308-langtools/dist/lib/javap.jar:" +
                                        "${tasks.shadowJar.archivePath}:${sourceSets.test.output.asPath}",

                                "-javacoptions:-Xbootclasspath/p:${configurations.javacJar.asPath}",
                        ]
                        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',
                    // Too broad, rejects seemingly-correct code.
                    '-Xep:EqualsGetClass:OFF',
		    // Not a real problem
		    '-Xep:MixedMutabilityReturnType:OFF',
		    // -Werror halts the build if Error Prone issues a warning, which ensures that
		    // the errors get fixed.  On the downside, Error Prone (or maybe the compiler?)
		    // stops as soon as it one warning, rather than outputting them all.
		    // https://github.com/google/error-prone/issues/436
 		    '-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 checkBasicStyle(group: 'Format') {
    description 'Check basic style guidelines.  Not related to Checkstyle tool.'
    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']
}
task releaseAndTest(type: GradleBuild, dependsOn: 'releaseBuild') {
    description 'Build everything required for a release and run allTests'
    startParameter = new StartParameter()
    startParameter.setProjectProperties(release: true)
    tasks = ['allTests']
}

// Don't create an empty checker-framework-VERSION.jar
jar.onlyIf {false}