block_launch_op.getResults());
  }

  return success();
}

// Creates a `tf.TPUCompileSucceededAssert` operation that parses compilation
// status of `compile_op` to check whether compilation is successful.
void BuildTPUCompileSucceededAssertOp(Operation* compile_op,
                                      Operation* result_id,

import spock.lang.Issue

abstract class CrossTaskIncrementalJavaCompilationIntegrationTest extends AbstractCrossTaskIncrementalCompilationIntegrationTest {
    CompiledLanguage language = CompiledLanguage.JAVA

    def "compilation fails for private dependents on incompatible change"() {
        source api: ["class A { int method() { return 1; } }"],

        run("impl:${language.compileTaskName}")

        then:
        impl.noneRecompiled()
    }

    def "new jar with duplicate class appearing earlier on classpath must trigger compilation"() {
        source impl: ["class A extends org.junit.Assert {}"]

        file("impl/build.gradle") << """
            configurations.implementation.dependencies.clear()
            dependencies {

You can also configure sources for each binary build for those cases where sources are compiled only on certain target machines.

.Sources and Swift compilation
image::swift-sourcesets-compilation.png[]

// TODO once we have the testing chapter
//Test sources are configured on each test suite script block. See <<swift_testing.adoc#swift_testing,Testing Swift projects>> chapter.

// RUN: tf-opt %s -split-input-file -verify-diagnostics -tf-mark-ops-for-outside-compilation | FILECHECK_OPTS="" FileCheck %s

func.func @unsupported_op_missing_soft_placement_attribute() -> tensor<i32> {
  %0 = "tf_device.cluster"() ({
    // expected-error@+1 {{'tf.UnsupportedOp' op isn't compilable for TPU device}}
    %1 = "tf.UnsupportedOp"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    %2 = "tf.Identity"(%1) : (tensor<i32>) -> tensor<i32>

You can also configure sources for each binary build for those cases where sources are compiled only on certain target machines.

.Sources and {cpp} compilation
image::cpp-sourcesets-compilation.png[]

Test sources are configured on each test suite script block. See <<cpp_testing.adoc#cpp_testing,Testing {cpp} projects>> chapter.

[[sec:cpp_dependency_management_overview]]

=== Use incremental compilation

Gradle can analyze dependencies down to the individual class level
to recompile only the classes affected by a change.
Gradle 4.10 and above enable incremental compilation by default.
To enable incremental compilation by default in older Gradle versions, add the following setting to your
`build.gradle` file:

====

Though moving the files around wouldn't have an effect on the result of the compilation, for incremental compilation the `JavaCompile` task relies on the relative path to find other classes in the same package.
Therefore, the path sensitivity for the sources of the `JavaCompile` task is `RELATIVE`.

    arguments.push_back(op_->getOperand(i));
  }

  // Ideally we could use the Function Importer but it increases compilation
  // time when we have a model with thousands of tf2xla op fallbacks. At time
  // of writing, this caused compilation time to be greater than 2x slower.
  // So we have to directly import these instructions.
  TF_ASSIGN_OR_RETURN(
      mlir::Value root_value,

        if (!moduleInfoSources.isEmpty()) {
            // Always recompile module-info.java if present.
            // This solves case for incremental compilation where some package was deleted and exported in module-info, but compilation doesn't fail.
            spec.addClassToCompile(MODULE_INFO_CLASS_NAME);
            spec.addSourcePaths(moduleInfoSources);
        }
    }

    @Override