"device"
            "forces compilation by XLA. Deprecated."),

       Flag("tf_xla_always_defer_compilation",
            &ops_flags->tf_xla_always_defer_compilation, ""),
       Flag("tf_xla_async_compilation", &ops_flags->tf_xla_async_compilation,
            "When lazy compilation is enabled, asynchronous compilation starts "
            "the cluster compilation in the background, and the fallback path "

Java 6 and 7 can be used for <<building_java_projects.adoc#sec:java_cross_compilation,compilation>> but are deprecated for use with testing. Testing with Java 6 and 7 will not be supported in Gradle 9.0.

Any fully supported version of Java can be used for compilation or testing.
However, the latest Java version may only be supported for compilation or testing, not for running Gradle.

            @org.codehaus.groovy.transform.GroovyASTTransformationClass("MyASTTransformation")
            public @interface MyAnnotation {}
        """
    }

    def 'always recompile if compilation avoidance is not enabled'() {
        given:
        settingsFile.text = settingsFile.text.readLines().findAll { !it.contains("enableFeaturePreview") }.join('\n')
        buildFile << """
            project(':b') {

                @ReplacesEagerProperty
                public abstract Property<String> getSourceCompatibility();
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        assertThat(compilation)
            .generatedFile(CLASS_OUTPUT, "META-INF/gradle/instrumentation/upgraded-properties.json")
            .contentsAsString(StandardCharsets.UTF_8)

  // have been produced by this client.
  absl::StatusOr<std::string> SerializeExecutable(
      const xla::PjRtLoadedExecutable& executable) override;

  // PjRt doesn't support AOT compilation yet. Builds a PjRtLoadedExecutable and
  // serializes it to string.
  absl::StatusOr<std::string> BuildSerializedExecutable(
      const XlaCompiler::Options& options,

    implementation 'commons-lang:commons-lang:2.6'
    testImplementation 'junit:junit:4.+'
}

// tag::java-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}
// end::java-cross-compilation[]

tasks.withType(Test) {
    systemProperty('targetJavaVersion', project.findProperty('targetJavaVersion'))
}

those provided by package "net/rpc".

The implementation compiles a custom codec for each data type in the stream
and is most efficient when a single Encoder is used to transmit a stream of
values, amortizing the cost of compilation.
-- text --
Package gob manages streams
of gobs - binary values
exchanged between an Encoder
(transmitter) and a Decoder
(receiver). A typical use is
transporting arguments and
results of remote procedure

    implementation("commons-lang:commons-lang:2.6")
    testImplementation("junit:junit:4.+")
}

// tag::java-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}
// end::java-cross-compilation[]

tasks.withType<Test>().configureEach {
    project.findProperty("targetJavaVersion")?.let { systemProperty("targetJavaVersion", it) }
}

====

[[sec:scala_incremental_compilation]]
== Incremental compilation

By compiling only classes whose source code has changed since the previous compilation, and classes affected by these changes, incremental compilation can significantly reduce Scala compilation time. It is particularly effective when frequently compiling small code increments, as is often done at development time.

}

dependencies {
    implementation 'commons-collections:commons-collections:3.2.2'
    testImplementation 'junit:junit:4.13'
}

// tag::force-compilation[]
tasks.withType(ScalaCompile) {
    scalaCompileOptions.with {
        force = true
    }
}