import org.gradle.internal.hash.Hashing;
import org.gradle.internal.snapshot.FileSystemLocationSnapshot;
import org.gradle.internal.snapshot.FileSystemLocationSnapshot.FileSystemLocationSnapshotVisitor;
import org.gradle.internal.snapshot.FileSystemSnapshot;
import org.gradle.internal.snapshot.MissingFileSnapshot;
import org.gradle.internal.snapshot.RegularFileSnapshot;
import org.gradle.internal.snapshot.RelativePathTracker;

        impl.snapshot { run language.compileTaskName }

        when:
        // A is changed so we expect X to recompile
        source api: ["class A { final static int x = 2; }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.recompiledClasses('X')

        when:
        impl.snapshot()
        // B is changed so we expect Y to recompile

        def oldNotRecentlyUsedGradleDist = versionedDistDirs(type.version("2.3.4"), daysToTriggerCleanup, "my-dist-2")
        if (type == DistType.SNAPSHOT) {
            // we need this so there is more than one snapshot distribution
            versionedDistDirs(type.alternateVersion("2.3.4"), USED_TODAY, "my-dist-3")
        }

        given:
        def anotherRepo = maven("another-local-repo")
        m2.mavenRepo().module('group', 'projectA', '1.2-SNAPSHOT').publishPom()
        def moduleARemote = anotherRepo.module('group', 'projectA', '1.2-SNAPSHOT').publish()

        and:
        buildFile.text = """
                repositories {
                    mavenLocal()
                    maven { url "${anotherRepo.uri}" }
                }

    }

    def "generated files are recompiled when annotated file changes"() {
        given:
        def a = java "@Helper class A {}"
        java "class Unrelated {}"

        outputs.snapshot { run "compileJava" }

        when:
        a.text = "@Helper class A { public void foo() {} }"
        run "compileJava"

        then:
        outputs.recompiledFiles("A", "AHelper", "AHelperResource.txt")

        file("src/main/java/foo/Consumer.java") << """
            package foo;
            public class Consumer {
                void consume() { StringUtils.foo(); }
            }
        """

        outputs.snapshot { run language.compileTaskName }

        when:
        file("src/main/java/foo/Strings.java").text = """
            package foo;
            public class Strings {

            }

        outputs = new CompilationOutputsFixture(objectFileDir)
    }

    @ToBeFixedForConfigurationCache
    def "recompiles changed source file only"() {
        given:
        outputs.snapshot { run "mainExecutable" }

        when:
        sourceFile << """
// Changed source file
"""
        and:
        run "mainExecutable"

        then:
        executedAndNotSkipped compileTask

        source "class A {}", "class B {}", "class C {}"
        outputs.snapshot { run language.compileTaskName }

        when:
        source "class B extends A {}"
        run language.compileTaskName

        then:
        outputs.recompiledClasses('B')

        when:
        outputs.snapshot()
        source "class A { /* change */ }"
        run language.compileTaskName

        then:

            apply plugin: 'swift-application'
         """
        outputs.snapshot { succeeds("compileDebugSwift") }

        when:
        main.replace("a: 5, b: 7", "a: 21, b: 21")
        and:
        succeeds("assemble")

        then:
        outputs.recompiledFile(main)

        when:
        outputs.snapshot()
        main.replace("a: 21, b: 21", "a: 5, b: 7")
        succeeds("compileDebugSwift")

        runAndFail language.compileTaskName
        outputs.snapshot { source("class A { }") }
        run "clean", language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B")
        !compileTransactionDir.exists()

        when: "Incremental compilation"
        outputs.snapshot { source("class A {}") }
        run language.compileTaskName

        then: