build.xml

<!--
  This is an Ant build file for compiling the Checker Framework.
-->
<project name="checker" default="dist" basedir=".">

    <description>
        Builds the Checker Framework.
    </description>

    <property file="build.${os.name}.properties"/>
    <property file="build.properties"/>
    <property file="${basedir}/../build-common.properties"/>

    <import file="../build-common.xml"/>


    <!-- Setting this via the command line "-Drun.tests.should.fork=false"
        causes the tests to crash. -->
    <property name="run.tests.should.fork" value="true"/>
    <property name="halt.on.test.failure" value="true"/>
    <property name="javadoc.private" value="false"/>

    <property environment="env"/>

    <!--
         NOTE LT_BIN IN THE NEXT FEW TARGETS IS SOLELY FOR bin-devel/javac and Jenkins.
         The original path to the langtools dir does not work on Jenkins.
         This is here so we get an empty value if it is not set
    -->
    <property name="LT_BIN" value=""/>


    <!-- Used to have:
           depends="touch-jdk"
         When is that truly necessary? -->
    <target name="prep" depends="prep-all"
            description="Create required directories">
        <mkdir dir="${build}"/>
        <mkdir dir="${tests.build}"/>
        <mkdir dir="${tests.build}/testclasses"/>
        <mkdir dir="${api.doc}" />

        <symlink link="${checkerframework}/docs/api" resource="../checker/${api.doc}" overwrite="true" failonerror="false"/>

        <available property="framework.project"
                   file="${framework.loc}/build.xml"/>
        <antcall target="-prep-framework-compile"/>

        <!-- Ant's copy task does not retain file permissions,
             so use <exec executable="cp"> instead.
        <copy file="bin-devel/git.post-merge" tofile="../.git/hooks/post-merge" preservelastmodified="true" />
        <copy file="bin-devel/git.pre-commit" tofile="../.git/hooks/pre-commit" preservelastmodified="true" />
        -->
        <exec executable="cp">
            <arg value="-p"/>
            <arg value="bin-devel/git.post-merge"/>
            <arg value="../.git/hooks/post-merge"/>
        </exec>
        <exec executable="cp">
            <arg value="-p"/>
            <arg value="bin-devel/git.pre-commit"/>
            <arg value="../.git/hooks/pre-commit"/>
        </exec>
    </target>

    <target name="-prep-framework-compile" if="framework.project"
            description="Compile framework project">
        <ant dir="${framework.loc}">
            <target name="dist"/>
        </ant>
    </target>

    <target name="clean" description="Remove generated files"
            depends="clean-nocleanjdk,clean-jdk">
    </target>

    <target name="clean-jdk" description="Remove generated jdkX.jar files">
        <delete file="dist/jdk8.jar"/>
        <delete file="dist/jdk9.jar"/>

        <delete file="jdk/jdk8.jar"/>
        <delete file="jdk/jdk9.jar"/>
    </target>

    <target name="clean-nocleanjdk" description="Remove generated files, but not the jdkX.jar files">
        <ant dir="${framework.loc}">
            <target name="clean"/>
        </ant>

        <delete dir="${build}"/>
        <delete dir="${api.doc}"/>
        <delete dir="${temp.dir}"/>

        <delete file="${checker.lib}"/>
        <delete file="${checker.qual.lib}"/>
        <delete file="${checker.qual.sources.lib}"/>
        <delete file="${checker.qual7.lib}"/>
        <delete file="${checker.qual7.sources.lib}"/>
        <delete file="${checker.compat.qual.lib}"/>
        <delete file="${checker.compat.qual.sources.lib}"/>
        <delete file="${checker.sources.lib}"/>
        <delete file="${checker.javadoc.lib}"/>

        <delete failonerror="false">
            <fileset dir="${tests.build}" includes="**/*.class"/>
            <fileset dir="jdk" includes="**/*.class"/>
            <fileset dir="${docs.loc}/examples" includes="**/*.class"/>
        </delete>

        <delete dir="${dist}"/>
        <delete dir="dist" failonerror="false"/>

        <ant dir="${checkerframework}">
            <target name="clean-tags"/>
        </ant>

        <exec executable="make" dir="${docs.loc}/manual" failonerror="true">
          <arg value="very_clean"/>
        </exec>

        <exec executable="make" dir="${dataflow.loc}/manual" failonerror="true">
          <arg value="clean"/>
        </exec>

    </target>

    <target name="clean-nojar" description="Remove generated class files, but not the .jar files">
        <delete dir="${build}"/>
    </target>


    <!-- Dependendencies on other projects (such as javacutil)
         mirrors javadoc dependencies. If changing project
         dependencies, change the Javadoc dependencies to keep
         them in sync (and vice versa). -->
    <target name="build.check.uptodate"
            description="Set properties: filesets and build.uptodate">
        <fileset id="src.files" dir="${src}">
            <include name="**/*.java"/>
            <exclude name="**/package-info.java"/>
        </fileset>

        <fileset id="dataflow.src.astub.files" dir="${dataflow.loc}/${src}">
            <include name="**/*.properties"/>
            <include name="**/*.astub"/>
        </fileset>

        <fileset id="framework.src.astub.files" dir="${framework.loc}/${src}">
            <include name="**/*.properties"/>
            <include name="**/*.astub"/>
        </fileset>

        <fileset id="checker.src.astub.files" dir="${checker.loc}/${src}">
            <include name="**/*.properties"/>
            <include name="**/*.astub"/>
        </fileset>

        <!-- I can't figure out how to combine filesets (or even selectors)
             to get just one *.uptodate property, so do them individually
             and then combine with <condition>. -->
        <!-- Probably should depend on a file rather than a directory. -->
        <uptodate property="src.files.uptodate" targetfile="${build}">
          <srcfiles refid="src.files"/>
          <mapper type="glob" from="*.java" to="../${build}/*.class"/>
        </uptodate>

        <uptodate property="src.astub.files.uptodate" targetfile="${build}">
          <srcfiles refid="dataflow.src.astub.files"/>
          <srcfiles refid="framework.src.astub.files"/>
          <srcfiles refid="checker.src.astub.files"/>
        </uptodate>

        <uptodate property="framework.lib.uptodate" targetfile="${build}" srcfile="${framework.lib}"/>

        <condition property="build.uptodate">
          <and>
            <isset property="src.files.uptodate"/>
            <isset property="src.astub.files.uptodate"/>
            <isset property="framework.lib.uptodate"/>
          </and>
        </condition>

        <!--
        <echo message="src.files.uptodate: ${src.files.uptodate}"/>
        <echo message="src.astub.files.uptodate: ${src.astub.files.uptodate}"/>
        <echo message="framework.lib.uptodate: ${framework.lib.uptodate}"/>
        <echo message="build.uptodate: ${build.uptodate}"/>
        -->
    </target>

    <target name="build" depends="prep,build.check.uptodate"
            unless="build.uptodate"
            description="Compile files.  Does not update any jars">

        <copy todir="${build}" preservelastmodified="true">
            <fileset refid="dataflow.src.astub.files"/>
            <fileset refid="framework.src.astub.files"/>
            <fileset refid="checker.src.astub.files"/>
        </copy>

        <pathconvert pathsep=" " property="src.files.spaceseparated">
            <path>
                <fileset dir="${src}">
                    <include name="**/*.java"/>
                </fileset>
                <!-- Recompile dependent projects with annotations-in-comments
                     enabled, in order to get classes with qualified types. -->
                <fileset dir="${javacutil.loc}/${src}">
                    <include name="**/*.java"/>
                <!-- Exclude ManualTaglet to not depend on javadoc. -->
                    <exclude name="**/javacutil/dist/**"/>
                </fileset>
                <fileset dir="${dataflow.loc}/${src}">
                    <include name="**/*.java"/>
                </fileset>
                <fileset dir="${framework.loc}/${src}">
                    <include name="**/*.java"/>
                </fileset>
            </path>
        </pathconvert>

        <echo message="Compiling all source files."/>
        <echo message="${src.files.spaceseparated}" file="${tmpdir}/srcfiles-checker.txt"/>
        <java fork="true"
              failonerror="true"
              classpath="${javac.lib}:${framework.lib}:${stubparser.lib}:${junit.lib}:${hamcrest.lib}:${annotation-file-utilities.lib}"
              classname="com.sun.tools.javac.Main">
            <arg value="-g"/>
            <!-- Make sure we only have Java 8 source code and generate Java 8 bytecode. -->
            <arg value="-source"/>
            <arg value="8"/>
            <arg value="-target"/>
            <arg value="8"/>
            <!-- To not get a warning about missing bootstrap
                 classpath for Java 8 (once we use Java 9). -->
            <arg value="-Xlint:-options"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-sourcepath"/>
            <arg value="${src}"/>
            <arg value="-d"/>
            <arg value="${build}"/>
            <arg value="@${tmpdir}/srcfiles-checker.txt"/>
            <arg value="-version"/>
            <arg value="-Xlint"/>
            <arg value="-Werror"/>
        </java>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>

        <!--
        Touch doesn't work on a directory, so can't do:
           <touch file="${build}"/>
        Instead, create and remove a file, which modifies the directory.
        -->
        <touch file="${build}/.timestamp"/>
        <delete file="${build}/.timestamp"/>
    </target>

    <!-- TODO: add a type-checking target that doesn't use
         -XDTA:noannotations in comments. -->

    <!-- Dependendencies on other projects (such as dataflow)
         mirrors javadoc dependencies. If changing project
         dependencies, change the Javadoc dependencies to keep
         them in sync (and vice versa). -->
    <target name="javadoc" depends="prep,prep-ManualTaglet,build.check.uptodate" description="Create Javadoc documentation">

        <!-- This relative path is wrong; running "ant -find" from a
        subdirectory fails. -->
        <!-- With Ant 1.9.4 or later, add to each javadoc task:
            failonwarning="true"
            but Travis is stuck on Ant 1.8.2 as of 6/2016 -->
        <javadoc sourcepath="${javacutil.loc}/${src}:${dataflow.loc}/${src}:${framework.loc}/${src}:${annotation-file-utilities.loc}/${src}"
                 destdir="${api.doc}"
                 private="${javadoc.private}"
                 encoding="UTF-8"
                 additionalParam="-Xdoclint:all,-missing"
                 failonerror="true"
                 executable="${javadoc.bin}"
                 classpath="${build}:${javac.lib}:${javadoc.lib}:${junit.lib}:${hamcrest.lib}:${annotation-file-utilities.lib}:${stubparser.lib}"
                 excludepackagenames="org.checkerframework.framework.stub">

            <package name="org.checkerframework.javacutil.*"/>
            <package name="org.checkerframework.dataflow.*"/>
            <package name="org.checkerframework.framework.*"/>
            <package name="org.checkerframework.common.*"/>
            <package name="org.checkerframework.checker.*"/>

            <fileset dir="${checker.loc}/${src}">
                <include name="**/*.java"/>
            </fileset>

            <link href="https://docs.oracle.com/javase/8/docs/api/"/>
            <link href="https://docs.oracle.com/javase/8/docs/jdk/api/javac/tree/"/>
            <taglet name="org.checkerframework.javacutil.dist.ManualTaglet"
                    path="${build}:${javacutil.loc}/${build}:${javacutil.lib}"/>
        </javadoc>
        <property name="favicon.targetfile" value="favicon-checkerframework.png"/>
        <copy file="../docs/logo/Checkmark/CFCheckmark_favicon.png" tofile="${api.doc}/${favicon.targetfile}" />
        <exec executable="../docs/logo/add-favicon" failonerror="true">
            <arg value="${api.doc}"/>
            <arg value="${favicon.targetfile}"/>
        </exec>
    </target>


    <target name="javadoc.jar" depends="javadoc" description="Create jar of all javadoc documentation">
        <jar destfile="${checker.javadoc.lib}" basedir="${api.doc}"></jar>
    </target>

    <!-- This creates checker-source.jar -->
    <target name="sources.jar" description="Create a jar of all source files except those in the jdk directory.">
        <property name="checker-sources-tmp" value="${tmpdir}/checker-sources"/>
        <mkdir dir="${checker-sources-tmp}"/>
        <copy todir="${checker-sources-tmp}">
            <!-- Copying like this removes the */src portion of the file -->
            <fileset dir="${checker.loc}/${src}"/>
            <fileset dir="${framework.loc}/${src}"/>
            <fileset dir="${dataflow.loc}/${src}"/>
            <fileset dir="${javacutil.loc}/${src}"/>
        </copy>

        <jar destfile="${checker.sources.lib}" basedir="${checker-sources-tmp}"/>
    </target>

    <!-- This creates checker.jar -->
    <target name="jar" depends="build,checker-qual-jar,checker-compat-qual-jar"
            description="Create checker.jar file">

        <mkdir dir="dist" />

        <!-- Only unjar the afu and stubparser - everything else is recompiled. -->

        <!-- jar up compilation results to protect against being
             overwritten by unjarring annotation-file-utilities.lib.
             See https://github.com/typetools/checker-framework/issues/894 -->
        <jar destfile="${checker.lib.tmp}" basedir="${build}" excludes="polyall/,tests/,lubglb/,jtreg/,reports/"/>
        <unjar src="${annotation-file-utilities.lib}" dest="${build}" />
        <!-- Also delete anything in the org/checkerframework package in case it has be removed
        from the framework-->
        <delete includeemptydirs="true">
            <fileset dir="${build}/org/checkerframework"/>
         </delete>
        <!-- Work-around for Issue 894, see above. -->
        <unjar src="${checker.lib.tmp}" dest="${build}" />
        <delete file="${checker.lib.tmp}"/>

        <unjar src="${stubparser.lib}" dest="${build}" />

        <jar destfile="${checker.lib}" basedir="${build}" excludes="polyall/,tests/,lubglb/,jtreg/,reports/">
            <manifest>
                <attribute name="Main-Class" value="org.checkerframework.framework.util.CheckerMain"/>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>
    </target>

    <!-- This creates checker-qual.jar and checker-qual-source.jar-->
    <target name="checker-qual-jar"
            description="Create checker-qual.jar file for annotations">
        <property name="checker-qual-sources-tmp" value="${tmpdir}/checker-qual-sources"/>
        <property name="checker-qual-classes-tmp" value="${tmpdir}/checker-qual-classes"/>
        <mkdir dir="${checker-qual-sources-tmp}"/>
        <mkdir dir="${checker-qual-classes-tmp}"/>

        <copy todir="${checker-qual-sources-tmp}">
            <!-- Copying like this removes the $CHECKERFRAMEWORK/checker/src portion of the file
            names so that the top level directory is org.-->
            <fileset dir="${checker.loc}/${src}">
                <include name="org/checkerframework/**/qual/*.java"/>
                <include name="**/FormatUtil.java"/>
                <include name="**/NullnessUtil.java"/>
                <include name="**/RegexUtil.java"/>
                <include name="**/UnitsTools.java"/>
                <include name="**/SignednessUtil.java"/>
                <include name="**/I18nFormatUtil.java"/>
                <exclude name="${checker.jdk8orhigher.sources}"/>
            </fileset>
            <fileset dir="${dataflow.loc}/${src}">
                <include name="org/checkerframework/**/qual/*.java"/>
            </fileset>
            <fileset dir="${framework.loc}/${src}">
                <include name="org/checkerframework/**/qual/*.java"/>
            </fileset>
        </copy>

        <pathconvert pathsep=" " property="qual.src.files.spaceseparated">
            <path>
                <fileset dir="${checker-qual-sources-tmp}">
                    <include name="**/*.java"/>
                </fileset>
            </path>
        </pathconvert>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>
        <echo message="${qual.src.files.spaceseparated}" file="${tmpdir}/srcfiles-checker.txt"/>
        <echo message="Compiling qualifiers."/>
        <java fork="true"
              failonerror="true"
              classname="com.sun.tools.javac.Main"
              classpath="${javac.lib}">
            <arg value="-g"/>
            <!-- Make sure we only have Java 7 source code and generate Java 7 bytecode. -->
            <arg value="-source"/>
            <arg value="7"/>
            <arg value="-target"/>
            <arg value="7"/>
            <!-- To not get a warning about missing bootstrap
                 classpath for Java 7. -->
            <arg value="-Xlint:-options"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-d"/>
            <arg value="${checker-qual-classes-tmp}"/>
            <arg value="@${tmpdir}/srcfiles-checker.txt"/>
            <arg value="-version"/>
            <arg value="-Xlint"/>
            <arg value="-Werror"/>
        </java>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>

        <!--Jar classes and source files-->
        <jar destfile="${checker.qual7.lib}" basedir="${checker-qual-classes-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>

        <jar destfile="${checker.qual7.sources.lib}" basedir="${checker-qual-sources-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>

        <!-- Compile and copy Java 8 sources -->
        <copy todir="${checker-qual-sources-tmp}">
            <!-- Copying like this removes the $CHECKERFRAMEWORK/checker/src portion of the file
            names so that the top level directory is org.-->
            <fileset dir="${checker.loc}/${src}">
                <include name="${checker.jdk8orhigher.sources}"/>
            </fileset>
        </copy>

        <pathconvert pathsep=" " property="qual.src8.files.spaceseparated">
            <path>
                <fileset dir="${checker-qual-sources-tmp}">
                    <include name="**/*.java"/>
                </fileset>
            </path>
        </pathconvert>
        <echo message="${qual.src8.files.spaceseparated}" append="true" file="${tmpdir}/srcfiles-checker.txt"/>


        <!-- Remove annotations in comments-->
        <replaceregexp match="\/\*@([^*]+)\*\/" replace="@\1" flags="g">
            <fileset dir="${checker-qual-sources-tmp}">
                <include name="**/*.java"/>
            </fileset>
        </replaceregexp>
        <replaceregexp match="\/\*>>>([^*]+)\*\/" replace="\1" flags="g">
            <fileset dir="${checker-qual-sources-tmp}">
                <include name="**/*.java"/>
            </fileset>
        </replaceregexp>

        <java fork="true"
              failonerror="true"
              classname="com.sun.tools.javac.Main"
              classpath="${javac.lib}">
            <arg value="-g"/>
            <arg value="-source"/>
            <arg value="8"/>
            <arg value="-target"/>
            <arg value="8"/>
            <!-- To not get a warning about missing bootstrap
                 classpath for Java 8 (once we use Java 9). -->
            <arg value="-Xlint:-options"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-d"/>
            <arg value="${checker-qual-classes-tmp}"/>
            <arg value="@${tmpdir}/srcfiles-checker.txt"/>
            <arg value="-Xlint"/>
            <arg value="-Werror"/>
        </java>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>

        <copy todir="${checker-qual-sources-tmp}">
            <!-- Copying like this removes the $CHECKERFRAMEWORK/checker/src portion of the file
            names so that the top level directory is org.-->
            <fileset dir="${checker.loc}/${src}">
                <include name="${checker.jdk8orhigher.sources}"/>
            </fileset>
        </copy>

        <!--Jar classes and source files-->
        <jar destfile="${checker.qual.lib}" basedir="${checker-qual-classes-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>

        <jar destfile="${checker.qual.sources.lib}" basedir="${checker-qual-sources-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>

        <delete dir="${checker-qual-sources-tmp}" failonerror="false"/>
        <delete dir="${checker-qual-classes-tmp}" failonerror="false"/>
    </target>

    <!-- This creates checker-compat-qual.jar and checker-compat-qual-source.jar-->
    <target name="checker-compat-qual-jar"
            description="Create checker-compat-qual.jar file for compatibility annotations">

        <property name="checker-compat-qual-sources-tmp" value="${tmpdir}/checker-compat-qual-sources"/>
        <property name="checker-compat-qual-classes-tmp" value="${tmpdir}/checker-compat-qual-classes"/>

        <mkdir dir="${checker-compat-qual-sources-tmp}"/>
        <mkdir dir="${checker-compat-qual-classes-tmp}"/>

        <copy todir="${checker-compat-qual-sources-tmp}">
            <!-- Copying like this removes the $CHECKERFRAMEWORK/checker/src portion of the file
            names so that the top level directory is org.-->
                <fileset dir="${src}">
                    <include name="**/compatqual/*.java"/>
                </fileset>
        </copy>

        <pathconvert pathsep=" " property="compat.qual.src.files.spaceseparated">
            <path>
                <fileset dir="${checker-compat-qual-sources-tmp}">
                    <include name="**/*.java"/>
                </fileset>
            </path>
        </pathconvert>

        <echo message="Compiling compatibility qualifiers."/>
        <echo message="${compat.qual.src.files.spaceseparated}" file="${tmpdir}/srcfiles-checker.txt"/>
        <java fork="true"
              failonerror="true"
              classname="com.sun.tools.javac.Main"
              classpath="${javac.lib}">
            <arg value="-g"/>
            <!-- Make sure we only generate Java 6 bytecode. -->
            <arg value="-source"/>
            <arg value="6"/>
            <arg value="-target"/>
            <arg value="6"/>
            <!-- To not get a warning about missing bootstrap
                 classpath for Java 6. -->
            <arg value="-Xlint:-options"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-d"/>
            <arg value="${checker-compat-qual-classes-tmp}"/>
            <arg value="@${tmpdir}/srcfiles-checker.txt"/>
            <arg value="-version"/>
            <arg value="-Xlint"/>
            <arg value="-Werror"/>
        </java>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>

        <jar destfile="${checker.compat.qual.lib}" basedir="${checker-compat-qual-classes-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>

        <jar destfile="${checker.compat.qual.sources.lib}"
             basedir="${checker-compat-qual-sources-tmp}">
            <manifest>
                <attribute name="Implementation-Version" value="${build.version}"/>
                <attribute name="Implementation-URL" value="https://checkerframework.org/"/>
            </manifest>
        </jar>
        <delete dir="${checker-compat-qual-sources-tmp}" failonerror="false"/>
        <delete dir="${checker-compat-qual-classes-tmp}" failonerror="false"/>

    </target>

    <target name="build-tests" depends="prep" description="Compile tests">
        <pathconvert pathsep=" " property="src.tests">
            <path>
                <fileset dir="${tests}">
                    <include name="src/**/*.java"/>
                </fileset>
            </path>
        </pathconvert>

        <java fork="true"
              failonerror="true"
              classpath="${build}:${javac.lib}:${junit.lib}:${hamcrest.lib}"
              classname="com.sun.tools.javac.Main">
            <arg value="-g"/>
            <arg value="-source"/>
            <arg value="8"/>
            <arg value="-target"/>
            <arg value="8"/>
            <!-- To not get a warning about missing bootstrap
                 classpath for Java 8 (once we use Java 9). -->
            <arg value="-Xlint:-options"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-sourcepath"/>
            <arg value="${tests}"/>
            <arg value="-d"/>
            <arg value="${tests.build}"/>
            <arg line="${src.tests}"/>
        </java>
    </target>

    <!-- TODO: DUPLICATED FOR ALL_TESTS -->
    <!-- Per the <test> element, output goes to ${build.reports} -->
    <target name="-run-tests" description="Generalized test runner">

        <condition property="should.emit.debug.str" value="true" else="false">
            <isset property="emit.test.debug"/>
        </condition>

        <condition property="debugger.str" value="-Xnoagent -Djava.compiler=NONE -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005" else="">
            <isset property="debugger.on"/>
        </condition>

        <mkdir dir="${build.reports}"/>

    <!-- non-debugging version: -->
    <!--
        <junit fork="${run.tests.should.fork}"
               dir="${basedir}"
               printsummary="false"
               haltonfailure="${halt.on.test.failure}"
               haltonerror="${halt.on.test.failure}"
               maxmemory="2500M"
               >
            <formatter type="xml"/>
    -->
    <!-- end of non-debugging version. -->

    <!-- debugging version: -->
        <junit fork="${run.tests.should.fork}"
               dir="${basedir}"
               haltonfailure="${halt.on.test.failure}"
               haltonerror="${halt.on.test.failure}"
               maxmemory="2500M"
               showoutput="true"
               printsummary="withOutAndErr"
               >
            <formatter type="plain" usefile="false"/>
            <jvmarg value="-Demit.test.debug=true"/>
    <!-- end of debugging version. -->

            <!-- plain output for debugging -->

            <jvmarg line="${debugger.str}"/> <!-- may be empty string -->

            <sysproperty key="JDK_JAR" value="${basedir}/dist/${jdkName}"/>
            <sysproperty key="emit.test.debug" value="${should.emit.debug.str}"/>
            <jvmarg value="-ea"/>

            <classpath>
                <pathelement path="${build}"/>
                <pathelement path="${tests.build}"/>
                <pathelement path="${javac.lib}"/>
                <pathelement path="${junit.lib}"/>
                <pathelement path="${hamcrest.lib}"/>
            </classpath>


            <test name="${param}" todir="${build.reports}"/>
        </junit>
    </target>

    <target name="all-tests" depends="all-tests-nojtreg, jtreg-tests"
            description="Run tests for all checkers and the framework"/>

    <!-- Used to guarantee that targets executed from other ant scripts do not cause unnecessary rebuilds -->
    <target name="all-tests-nobuildjdk" depends="all-tests-nojtreg-nobuildjdk, jtreg-tests"
            description="Run tests for all checkers and the framework, WITHOUT updating jdkX.jar">
    </target>

    <target name="all-tests-nojtreg" depends="jdk.jar, all-tests-nojtreg-nobuildjdk"
            description="Run tests for all checkers and the framework, except jtreg tests"/>

    <!-- Used to guarantee that targets executed from other ant scripts do not cause unnecessary rebuilds -->
    <target name="all-tests-nojtreg-nobuildjdk" depends="jar, jdk.jar.exists, all-tests-nojtreg-nobuild"
            description="Run tests for all checkers and the framework, except jtreg tests, WITHOUT updating jdkX.jar">
    </target>

    <!-- Used to guarantee that targets executed from other ant scripts do not cause unnecessary rebuilds -->
    <target name="all-tests-nojtreg-nobuild"
            depends="junit-tests-nojtreg-nobuild,nonjunit-tests-nojtreg-nobuild"
            description="Run tests for all checkers, WITHOUT building anything">
    </target>

    <!-- Used to guarantee that targets executed from other ant scripts do not cause unnecessary rebuilds -->
    <target name="junit-tests-nojtreg-nobuild" depends="build-tests"
            description="Run junit tests for all checkers, WITHOUT building anything">

        <condition property="should.emit.debug.str" value="true" else="false">
            <isset property="emit.test.debug"/>
        </condition>

        <condition property="debugger.str" value="-Xnoagent -Djava.compiler=NONE -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005" else="">
            <isset property="debugger.on"/>
        </condition>

        <!-- Delete directory because we will rerun all tests -->
        <delete dir="${build.reports}"/>
        <!-- Copied from -run-tests target -->
        <mkdir dir="${build.reports}"/>

        <junit fork="${run.tests.should.fork}"
               dir="${basedir}"
               printsummary="false"
               haltonerror="${halt.on.test.failure}"
               haltonfailure="${halt.on.test.failure}">
            <jvmarg value="-ea"/>
            <jvmarg line="${debugger.str}"/>  <!-- may be empty string -->
            <sysproperty key="JDK_JAR" value="${basedir}/dist/${jdkName}"/>
            <sysproperty key="emit.test.debug" value="${should.emit.debug.str}"/>

            <classpath>
              <pathelement path="${build}"/>
              <pathelement path="${tests.build}"/>
              <pathelement path="${javac.lib}"/>
              <pathelement path="${junit.lib}"/>
              <pathelement path="${hamcrest.lib}"/>
            </classpath>

            <formatter type="xml"/>
            <formatter type="brief" usefile="false"/>

            <batchtest todir="${build.reports}">
                <fileset dir="${tests}/${src}">
                    <include name="tests/*.java"/>
                </fileset>
            </batchtest>
        </junit>

    </target>

    <!-- Used to guarantee that targets executed from other ant scripts do not cause unnecessary rebuilds -->
    <target name="nonjunit-tests-nojtreg-nobuild" depends="build-tests"
            description="Run tests, other than junit tests for all checkers, WITHOUT building anything">

        <condition property="should.emit.debug.str" value="true" else="false">
            <isset property="emit.test.debug"/>
        </condition>

        <condition property="debugger.str" value="-Xnoagent -Djava.compiler=NONE -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005" else="">
            <isset property="debugger.on"/>
        </condition>

        <ant dir="${framework.loc}" inheritAll="false">
            <target name="all-tests-nojtreg-nobuild"/>
        </ant>

        <!-- Delete directory because we will rerun all tests -->
        <delete dir="${build.reports}"/>
        <!-- Copied from -run-tests target -->
        <mkdir dir="${build.reports}"/>

        <antcall target="nullness-extra-tests-nobuildjdk"/>

        <antcall target="command-line-tests"/>

      <!--TODO: This breaks during the release process because the latest Maven artifacts haven't been created.
                This target is called in .travis-build.sh -->
        <!--<antcall target="example-tests-nobuildjdk"/>-->

        <antcall target="check-tutorial"/>
        <antcall target="check-compilermsgs"/>
        <antcall target="check-purity"/>

        <!-- Eventually we would also want this:
          <antcall target="check-nullness"/>
        -->
    </target>

    <target name="aggregate-tests" depends="jar,build-tests"
            description="Run tests for the aggregate checkers">
        <antcall target="-run-tests">
            <param name="param" value="tests.NestedAggregateCheckerTest"/>
        </antcall>
    </target>

    <target name="command-line-tests" depends="jar,build-tests"
            description="Run tests that need a special command line">
        <exec executable="make" failonerror="${halt.on.test.failure}">
            <env key="JAVAC" value="${basedir}/bin/javac"/>
            <arg value="-C"/>
            <arg value="tests/command-line/"/>
        </exec>
    </target>

    <target name="compilermsg-tests" depends="jar,build-tests"
            description="Run tests for the Compiler Messages Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.CompilerMessagesTest"/>
        </antcall>
    </target>

    <target name="fenum-tests" depends="jar,build-tests"
            description="Run tests for the Fenum Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.FenumTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.FenumSwingTest"/>
        </antcall>
    </target>

    <target name="i18n-tests" depends="jar,build-tests"
            description="Run tests for the I18n Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.I18nTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.I18nUncheckedDefaultsTest"/>
        </antcall>
    </target>

    <target name="index-tests" depends="jar,jdk.jar.exists,build-tests"
            description="Run tests for the Index Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.IndexTest"/>
        </antcall>
    </target>

    <target name="interning-tests" depends="jar,build-tests"
            description="Run tests for the Interning Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.InterningTest"/>
        </antcall>
    </target>

    <target name="lock-tests" depends="jar,jdk.jar.exists,build-tests"
            description="Run tests for the Lock Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.LockTest"/>
        </antcall>
    </target>

    <target name="lock-safedefaults-tests" depends="jar,build-tests"
            description="Run tests for the Lock Checker with unchecked code defaults turned on for source code">
        <antcall target="-run-tests">
            <param name="param" value="tests.LockSafeDefaultsTest"/>
        </antcall>
    </target>

    <target name="lubglb-tests" depends="jar,build-tests"
            description="Run tests for the Lubglb Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.LubGlbTest"/>
        </antcall>
    </target>

    <target name="nullness-tests"
            depends="jdk.jar,nullness-tests-nobuildjdk"
            description="Run tests for the Nullness Checker">
    </target>

    <target name="nullness-tests-nobuildjdk"
            depends="jar,jdk.jar.exists,build-tests,nullness-base-tests,nullness-base-tests-with-asserts,nullness-concurrent-tests,nullness-skipuses-tests,nullness-skipdefs-tests,nullness-uninit-tests,nullness-uninit-tests-with-asserts,nullness-assume-assertions-are-enabled-tests,nullness-extra-tests-nobuildjdk,nullness-reflection-tests,nullness-invariantarrays-tests,nullness-safedefaultsbytecode-tests,nullness-safedefaultssourcecode-tests,nullness-checkcastelementtype"
            description="Run tests for the Nullness Checker, WITHOUT updating jdkX.jar">
    </target>

    <target name="nullness-base-tests" depends="jar,build-tests"
            description="Run base tests for the FBC Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessFbcTest"/>
        </antcall>
    </target>

    <target name="nullness-uninit-tests" depends="jar,build-tests"
            description="Run base tests for the rawness Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessRawnessTest"/>
        </antcall>
    </target>

    <target name="nullness-base-tests-with-asserts" depends="jar,build-tests"
            description="Run base tests for the FBC Nullness Checker, with assertions">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessFbcTestWithAsserts"/>
        </antcall>
    </target>


    <target name="nullness-assume-assertions-are-enabled-tests" depends="jar,build-tests"
            description="Run base tests for the Nullness Checker, assuming assertions are disabled">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessAssumeAssertionsAreDisabled"/>
        </antcall>
    </target>

    <target name="nullness-uninit-tests-with-asserts" depends="jar,build-tests"
            description="Run base tests for the rawness Nullness Checker, with assertions">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessRawnessTestWithAsserts"/>
        </antcall>
    </target>

    <target name="nullness-checkcastelementtype" depends="jar,build-tests"
            description="Run base tests for the rawness Nullness Checker, with assertions">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessCheckCastElementTypeTest"/>
        </antcall>
    </target>

    <target name="signedness-tests" depends="jar,build-tests"
            description="Run tests for the Signedness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.SignednessTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.SignednessUncheckedDefaultsTest"/>
        </antcall>
    </target>

    <!-- Differs from other targets in that it is defined via a Makefile and
       is not run via the "-run-tests" Antfile target, as other tests are. -->
    <target name="nullness-extra-tests" depends="dist,build-tests,nullness-extra-tests-nobuildjdk"
            description="Run extra tests for the Nullness Checker"/>

    <target name="nullness-extra-tests-nobuildjdk" depends="dist-nobuildjdk,jdk.jar.exists,build-tests"
            description="Run extra tests for the Nullness Checker, WITHOUT updating jdkX.jar">
        <exec executable="chmod" failonerror="true">
            <arg value="+x"/>
            <arg value="${basedir}/bin/javac"/>
        </exec>

        <exec executable="make" failonerror="${halt.on.test.failure}">
            <env key="JAVAC" value="${basedir}/bin/javac"/>
            <env key="JAVAP" value="${jsr308.langtools.dist}/bin/javap"/>
            <arg value="-C"/>
            <arg value="tests/nullness-extra/"/>
        </exec>
    </target>

    <target name="nullness-skipuses-tests" depends="jar,build-tests"
            description="Run skipuses tests for the Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessSkipUsesTest"/>
        </antcall>
    </target>

    <target name="nullness-skipdefs-tests" depends="jar,build-tests"
            description="Run skipdefs tests for the Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessSkipDefsTest"/>
        </antcall>
    </target>

    <target name="nullness-concurrent-tests" depends="jar,build-tests"
            description="Run concurrent semantics tests for the Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessConcurrentTest"/>
        </antcall>
    </target>

    <target name="nullness-invariantarrays-tests" depends="jar,build-tests"
            description="Run tests for the Nullness Checker using -AinvariantArrays">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessInvariantArraysTest"/>
        </antcall>
    </target>

    <target name="nullness-reflection-tests" depends="jar,build-tests"
            description="Run tests for the Nullness Checker using reflection resolution">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessReflectionTest"/>
        </antcall>
    </target>

    <target name="nullness-safedefaultsbytecode-tests" depends="jar,build-tests"
            description="Run tests for the Nullness Checker using -AuseDefaultsForUncheckedCode=-source,bytecode">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessSafeDefaultsBytecodeTest"/>
        </antcall>
    </target>

    <target name="nullness-safedefaultssourcecodelib-tests" depends="jar,build-tests"
            description="Create libraries for tests for the Nullness Checker using -AuseDefaultsForUncheckedCode=source,bytecode">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessSafeDefaultsSourceCodeLibTest"/>
        </antcall>
    </target>

    <target name="nullness-safedefaultssourcecode-tests" depends="jar,build-tests,nullness-safedefaultssourcecodelib-tests"
            description="Run tests for the Nullness Checker using -AuseDefaultsForUncheckedCode=source">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessSafeDefaultsSourceCodeTest"/>
        </antcall>
    </target>

    <target name="nullness-genericwildcardlib-tests" depends="jar,build-tests"
            description="Create libraries for tests for the Nullness Checker for issue #511">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessGenericWildcardLibTest"/>
        </antcall>
    </target>

    <target name="nullness-genericwildcard-tests" depends="jar,build-tests,nullness-genericwildcardlib-tests"
            description="Run tests for the Nullness Checker for issue #511">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessGenericWildcardTest"/>
        </antcall>
    </target>

    <target name="nullness-stubfile-tests" depends="jar,build-tests"
            description="Run stubfile tests for the Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessStubfileTest"/>
        </antcall>
    </target>

    <!-- Do not include this as a dependence for nullness-tests! -->
    <target name="nullness-temp-tests" depends="jar,build-tests"
            description="Run temporary tests for the Nullness Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.NullnessTempTest"/>
        </antcall>
    </target>

    <target name="formatter-tests" depends="jar,build-tests"
            description="Run tests for the Formatter Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.FormatterUncheckedDefaultsTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.FormatterTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.FormatterLubGlbCheckerTest"/>
        </antcall>
    </target>

    <target name="i18n-formatter-tests" depends="jar,build-tests"
            description="Run tests for the Internationalization Formatter checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.I18nFormatterTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.I18nFormatterLubGlbCheckerTest"/>
        </antcall>
        <antcall target="-run-tests">
            <param name="param" value="tests.I18nFormatterUncheckedDefaultsTest"/>
        </antcall>
    </target>

    <target name="regex-tests" depends="jar,build-tests"
            description="Run tests for the Regex Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.RegexTest"/>
        </antcall>
    </target>

    <target name="signature-tests" depends="jar,build-tests"
            description="Run tests for the Signature Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.SignatureTest"/>
        </antcall>
    </target>

    <target name="tainting-tests" depends="jar,build-tests"
            description="Run tests for the classic Tainting Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.TaintingTest"/>
        </antcall>
    </target>

    <target name="units-tests" depends="jar,build-tests"
            description="Run tests for the Units Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.UnitsTest"/>
        </antcall>
    </target>

    <target name="value-index-interaction-tests" depends="jar,build-tests"
            description="Run tests for the interaction between the Value Checker and the Index Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.ValueIndexInteractionTest"/>
        </antcall>
    </target>

    <target name="guieffect-tests" depends="jar,build-tests"
            description="Run tests for the GUI Effect Checker">
        <antcall target="-run-tests">
            <param name="param" value="tests.GuiEffectTest"/>
        </antcall>
    </target>

    <target name="example-tests" depends="dist,example-tests-nobuildjdk"
            description="Run tests for the example programs">
    </target>

    <target name="example-tests-nobuildjdk" depends="dist-nobuildjdk,jdk.jar.exists,build-tests"
            description="Run tests for the example programs, WITHOUT updating jdkX.jar">
      <exec executable="chmod" failonerror="true">
        <arg value="+x"/>
        <arg value="${basedir}/bin/javac"/>
      </exec>

      <exec executable="make" failonerror="${halt.on.test.failure}">
        <env key="JAVAC" value="${basedir}/bin/javac"/>
        <arg value="CHECKERFRAMEWORK=${checkerframework}"/>
        <arg value="-C"/>
        <arg value="../docs/examples/"/>
      </exec>
    </target>



    <target name="jtreg.check">
      <condition property="jtreg.exists">
        <available file="${jtreg.home}" type="dir"/>
      </condition>
    </target>

    <target name="-jtreg.download" depends="jtreg.check" unless="jtreg.exists">
      <get
        src="https://adopt-openjdk.ci.cloudbees.com/job/jtreg/lastSuccessfulBuild/artifact/jtreg-4.2.0-tip.tar.gz"
        dest="${jtreg.home}/.." />
      <untar src="${jtreg.home}/../jtreg-4.2.0-tip.tar.gz"
        dest="${jtreg.home}/../"
        compression="gzip" />
    </target>


    <target name="jtreg-tests"
            depends="-jtreg.download,-def-jtreg,jar,jtreg-tests-checkers,jtreg-tests-framework"
            description="Run all jtreg tests">
    </target>

    <target name="jtreg-tests-checkers" depends="-def-jtreg,jar"
            description="Run checker jtreg tests">
        <jtreg-tool name="all" tests="."/>
    </target>

    <target name="jtreg-tests-framework" depends="-def-jtreg,jar"
            description="Run framework jtreg tests">
       <ant dir="${framework.loc}">
           <target name="jtreg-tests" />
       </ant>
    </target>

    <target name="-def-check">
        <macrodef name="check">
            <attribute name="name"/>
            <attribute name="property"/>
            <attribute name="marker"/>
            <sequential>
                <fail message="Cannot locate @{name}: please set @{property} to its location">
                    <condition>
                        <not>
                            <isset property="@{property}"/>
                        </not>
                    </condition>
                </fail>

                <fail message="@{name} is not installed in ${@{property}}">
                    <condition>
                        <not>
                            <available file="${@{property}}/@{marker}"/>
                        </not>
                    </condition>
                </fail>
            </sequential>
        </macrodef>
    </target>

    <target name="-check-jtreg.home" depends="-def-check">
        <check name="jtreg" property="jtreg.home" marker="lib/jtreg.jar"/>
    </target>

    <target name="-def-jtreg" unless="jtreg.defined" depends="-check-jtreg.home">
        <taskdef name="jtreg" classname="com.sun.javatest.regtest.Main$$Ant">
            <classpath>
                <pathelement location="${jtreg.home}/lib/jtreg.jar"/>
                <pathelement location="${jtreg.home}/lib/javatest.jar"/>
            </classpath>
        </taskdef>

        <macrodef name="jtreg-tool">
            <attribute name="name"/>
            <attribute name="tests"/>
            <!-- <attribute name="jdk" default="${java.home}"/> -->
            <!-- TODO samevm true does not work. Investigate. -->
            <attribute name="samevm" default="false"/>
            <attribute name="verbose" default="summary"/>
            <attribute name="options" default=""/>
            <attribute name="keywords" default="-keywords:!ignore"/>
            <attribute name="jpda.jvmargs" default=""/>

            <sequential>
                <!--As of version 4.2-b02, a NullPointerException is thrown without making this dir-->
                <mkdir dir="${build}/jtreg/all/report/html"/>
                <mkdir dir="${build}/jtreg/all/report/text"/>

                <property name="coverage.options" value=""/>    <!-- default -->
                <property name="coverage.classpath" value=""/>  <!-- default -->
                <property name="checker.classpath" value="${build}:${javac.lib}:${javap.lib}:${checker.lib}"/>
                <jtreg
                    dir="jtreg"
                    workDir="${build.jtreg.dir}/@{name}/work"
                    reportDir="${build.jtreg.dir}/@{name}/report"
                    samevm="@{samevm}" verbose="@{verbose}"
                    failonerror="${halt.on.test.failure}" resultproperty="jtreg.@{name}.result"
                    javacoptions="-g -Xbootclasspath/p:${basedir}/dist/${jdkName}"
                    vmoptions="${coverage.options} -Xbootclasspath/p:${coverage.classpath}:${build}:${checker.classpath} @{jpda.jvmargs}">
                    <arg line="@{keywords}"/>
                    <arg line="@{options}"/>
                    <arg line="@{tests}"/>
                </jtreg>

                <!-- the next two properties are for convenience, when only
                     a single instance of jtreg will be invoked. -->
                <condition property="jtreg.passed">
                    <equals arg1="${jtreg.@{name}.result}" arg2="0"/>
                </condition>
                <property name="jtreg.report" value="${build.jtreg.dir}/@{name}/report"/>
            </sequential>
        </macrodef>
        <property name="jtreg.defined" value="true"/>
    </target>

    <!-- Type-check the checker implementations -->

    <!-- TODO: it looks like this target only compiles the
         code in "checker/src". It should also compile the source
         for the other projects. Can we do this here or do we need
         to duplicate the targets in the other build files? -->

    <!-- depends on jar, needs classfile of the checker itself -->
    <target name="-run-checker" depends="jar"
            description="Run a checker on the Checker Framework">
        <pathconvert pathsep=" " property="src.files">
            <path>
                <fileset dir="${src}">
                    <include name="**/*.java"/>
                </fileset>
                <fileset dir="${javacutil.loc}/${src}">
                    <include name="**/*.java"/>
                    <!-- Exclude ManualTaglet to not depend on javadoc. -->
                    <exclude name="**/javacutil/dist/**"/>
                </fileset>

                <!-- Do not check dataflow, it doesn't have all purity
                     annotations. TODO: should be easy to fix. Or solved
                     once we inherit those annotations.
                <fileset dir="${dataflow.loc}/${src}">
                    <include name="**/*.java"/>
                </fileset>
                -->
                <fileset dir="${framework.loc}/${src}">
                    <include name="**/*.java"/>
                </fileset>
                <!-- TODO: check-nullness doesn't properly work with this.
                <fileset dir="${checker-jdk}" erroronmissingdir="false">
                    <include name="**/*.java"/>
                </fileset>
                -->
            </path>
        </pathconvert>

        <condition property="maybeDebug" value="-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=${debugPort}" else="">
            <isset property="debugPort"/>
        </condition>

        <echo message="${src.files}" file="${tmpdir}/srcfiles-checker.txt"/>

        <echo message="Applying ${checker-name} to the Checker Framework sources."/>
        <!-- Use this if you want to see the file names:
        <echo message="Applying ${checker-name} to: ${src.files}"/>
        -->
        <java fork="true"
              failonerror="true"
              classpath="${build}:${javac.lib}:${checker.lib}:${framework.lib}:${stubparser.lib}:${junit.lib}:${hamcrest.lib}:${annotation-file-utilities.lib}"
              classname="com.sun.tools.javac.Main">
            <jvmarg line="${maybeDebug}"/>  <!-- may be empty string -->
            <arg value="-g"/>
            <arg value="-encoding"/>
            <arg value="utf-8"/>
            <arg value="-d"/>
            <arg value="${build}"/>
            <arg value="@${tmpdir}/srcfiles-checker.txt"/>
            <arg value="-version"/>
            <arg value="-proc:only"/>
            <arg value="-processor"/>
            <arg value="${checker-name}"/>
            <arg value="-AprintErrorStack"/>
            <arg line="${checker-args}"/>
        </java>
        <delete file="${tmpdir}/srcfiles-checker.txt"/>
    </target>

    <target name="check-nullness"
            description="Run the Nullness Checker on the Checker Framework source code">
        <antcall target="-run-checker">
            <param name="checker-name" value="org.checkerframework.checker.nullness.NullnessChecker"/>
            <param name="checker-jdk" value="jdk/nullness/src"/>
            <param name="checker-args" value="-Awarns -Xmaxwarns 10000"/>
        </antcall>
    </target>

    <fileset dir=".." id="messages.properties.files">
      <include name="**/messages.properties"/>
    </fileset>

    <pathconvert pathsep=":" property="messages.properties.concatenated" refid="messages.properties.files">
    </pathconvert>

    <target name="check-compilermsgs"
            description="Run the compiler message keys checker on the Framework">
        <antcall target="-run-checker">
            <param name="checker-name" value="org.checkerframework.checker.compilermsgs.CompilerMessagesChecker"/>
            <param name="checker-args" value="-Apropfiles=${messages.properties.concatenated}"/>
        </antcall>
    </target>

    <target name="check-purity"
            description="Run the Purity Checker on the Framework">
        <antcall target="-run-checker">
            <param name="checker-name" value="org.checkerframework.framework.util.PurityChecker"/>
            <param name="checker-args" value=""/>
        </antcall>
    </target>


    <target name="check-tutorial" description="Test that the tutorial is working as expected">
    <!--The tutorial build file is written relative to its location,
        so useNativeBasedir is required. -->
          <ant dir="${docs.loc}/tutorial/tests/" useNativeBasedir="true">
              <target name="check-tutorial"/>
          </ant>
          <ant dir="${docs.loc}/tutorial/eclipse-projects/personalblog-demo" useNativeBasedir="true">
              <target name="clean"/>
          </ant>
    </target>

    <target name="demos.check">
      <condition property="demos.exists">
        <available file="${basedir}/../../checker-framework-demos"/>
      </condition>
    </target>

    <target name="-demos.pull" depends="demos.check" if="demos.exists">
      <exec executable="git" dir="${basedir}/../../checker-framework-demos" failonerror="true">
        <arg value="pull"/>
      </exec>
    </target>

    <target name="-demos.clone" depends="demos.check" unless="demos.exists">
      <exec executable="git" dir="${basedir}/../.." failonerror="true">
        <arg value="clone"/>
        <arg value="https://github.com/typetools/checker-framework.demos.git"/>
        <arg value="checker-framework-demos"/>
      </exec>
    </target>

    <target name="check-demos" depends="demos.check,-demos.pull,-demos.clone"
        description="Test that the demos are working as expected">
      <ant dir="${basedir}/../../checker-framework-demos">
      </ant>
    </target>

    <!-- This throws off dependency tracking and causes rebuilding.
         When is it truly necessary? -->
    <!-- Why all JDK files?  Why not just source files? -->
    <target name="touch-jdk"
            description="Update the date of all jdk files">
        <touch>
            <fileset dir="jdk">
                <include name="**/*"/>
            </fileset>
        </touch>
    </target>

    <!--
      Binary release of the Checker Framework; it includes javac.
     -->

    <property name="temp.dir" value="build-temp"/>

    <target name="-prep-dist"
            description="Ensure that the necessary jar files exist">
        <available property="javac.exist" file="${javac.lib}" />

        <fail unless="javac.exist" message="Could not find javac.jar: ${javac.lib}" />
    </target>

    <target name="download-jdk" description="Downloads jdk8.jar from checkerframework.org/dev-jdk to checker/jdk and checker/dist">
        <!-- See instructions for updating the jdk.jar at https://github.com/typetools/annotated-libraries/blob/master/README.jdk -->
        <get src="https://github.com/typetools/annotated-libraries/raw/36f721f6529be400ef64c309d7658ed62564af7d/jdk8.jar" dest="jdk/jdk8.jar"
             usetimestamp="true"/>

        <!-- Copy jars to dist. If dist doesn't exist then the copy task creates it.-->
        <copy file="jdk/jdk8.jar" tofile="dist/jdk8.jar"/>


        <!--The implementation version listed in the Manifest is the hash of the commit of-->
        <!--the Checker Framework that created the jdk.jar.  Show it here to help debugging.-->
        <loadfile property="message">
            <zipentry zipfile="jdk/jdk8.jar" name="META-INF/MANIFEST.MF"/>
        </loadfile>
        <echo>"Manifest file from jdk8.jar:"</echo>
        <echo>"${message}"</echo>


    </target>

    <!--This target is used during the release.  Currently, only jdk8.jar is built, so this target
     depends on the "jdk.jar" target.  When the Checker Framework can build jdk9.jar, the "depends"
     should be removed. -->
    <target name="all.jdks.jar" description="Build jdkX.jar using JAVA_X_HOME (with X in 8)"  depends="jdk.jar">
       <!--<fail unless="env.JAVA_8_HOME" message="Environment variable &quot;JAVA_8_HOME&quot; needs to be set!"/>-->
        <!--<fail unless="env.JAVA_9_HOME" message="Environment variable  &quot;JAVA_9_HOME&quot; needs to be set!"/>-->

        <!--<exec executable="ant" failonerror="true">
            <arg value="jdk.jar"/>
            <env key="JAVA_HOME"  value="${env.JAVA_8_HOME}"/>
            <env key="LT_BIN" value="${LT_BIN}"/>
        </exec>-->

        <!--<exec executable="ant" failonerror="true">
            <arg value="jdk.jar"/>
            <env key="JAVA_HOME"  value="${env.JAVA_9_HOME}"/>
        </exec>-->

    </target>

    <target name="jdk.jar" depends="jar"
            description="Create the instrumented jdkX.jar using the JDK specified by JAVA_HOME">
      <fail unless="env.JAVA_HOME" message="Environment variable JAVA_HOME is not set."/>
      <property name="annotation-file-utilities.jar" value="${annotation.tools}/annotation-file-utilities/annotation-file-utilities.jar"/>
      <available property="annotation-file-utilities.exist" file="${annotation-file-utilities.jar}" />
      <fail unless="annotation-file-utilities.exist" message="Could not find annotation-file-utilities.jar: ${annotation-file-utilities.jar}.  You must build Annotation Tools; see https://checkerframework.org/manual/#build-source" />

      <exec executable="make" failonerror="true">
         <arg value="CHECKERFRAMEWORK=${checkerframework}"/>
         <arg value="LANGTOOLS=${jsr308.langtools}"/>
         <arg value="LANGTOOLSDIST=${jsr308.langtools.dist}"/>
         <arg value="ANNOTATION_TOOLS=${annotation.tools}"/>
         <arg value="CLASSPATH=${basedir}/${build}"/>
         <arg value="-C"/>
         <arg value="jdk"/>
         <env key="LT_BIN" value="${LT_BIN}"/>
      </exec>
      <move file="jdk/jdk.jar" tofile="jdk/${jdkName}"/>
      <!-- Copy jars to dist. If dist doesn't exist then the copy task creates it.-->
      <copy file="jdk/${jdkName}" tofile="dist/${jdkName}"/>

    </target>

    <target name="dist-release" depends="clean, dist-all, all-tests-nojtreg-nobuild, javadoc.jar, sources.jar"
            description="Everything necessary to prepare this project for distribution: binary distribution, testing, and documentation.">
    </target>

    <!-- Like dist-release, but don't run the tests which take a very long time.  Use only during testing. -->
    <target name="dist-release-notest" depends="clean, dist-all, javadoc.jar, sources.jar"
            description="Everything necessary to prepare this project for distribution: binary distribution, [no testing], and documentation.">
    </target>

    <target name="dist-all"
            depends="-prep-dist,jar,all.jdks.jar,dist-nobuildjdk"
            description="Build checker.jar, checker-qual.jar, and all jdkX.jar(s).  This comprises all jars needed to run the framework.">
    </target>

    <target name="dist"
            depends="-prep-dist,jar,jdk.jar,dist-nobuildjdk"
            description="Build checker.jar, checker-qual.jar, and one jdkX.jar where X is the major version number of java in JAVA_HOME (only Java 7/8/9 are currently supported).  This comprises all jars needed to run the framework.">
    </target>

    <target name="dist-downloadjdk" depends="download-jdk,dist-nobuildjdk"
            description="Build checker.jar, checker-qual.jar, and download the jdkX.jars rather than building them."/>

    <target name="dist-nobuildjdk"
            depends="-prep-dist,jar,jdk.jar.exists"
            description="Build checker.jar, checker-qual.jar WITHOUT updating jdkX.jar.  Move all relevant files to the binary directory.">

        <mkdir dir="dist" />

        <copy tofile="dist/javac.jar" file="${javac.lib}"
              overwrite="true" failonerror="true" />
    </target>

    <target name="jdk.jar.exists"
            description="Check whether an annotated JDK exists.">
        <condition property="an.annotated.jdk.exists">
            <or>
                <available file="jdk/jdk8.jar"/>
                <available file="jdk/jdk9.jar"/>
            </or>
        </condition>

        <fail message="No jdk jars were found in the jdk directory.  At least one annotated JDK (jdk/jdk8.jar) must be built!"
              unless="an.annotated.jdk.exists"/>
    </target>

    <!-- For debugging -->
    <target name="showvars" depends="prep">
        <echo>[java.home] ${java.home}</echo>
    </target>

</project>