// Check that lazy compilation is disallowed.
  status = xla_device_compiler->CompileIfNeeded(
      XlaCompiler::Options{}, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kLazy, profiler, &compilation_result, &executable);
  EXPECT_FALSE(status.ok());
  EXPECT_TRUE(absl::StrContains(status.message(), "XLA compilation disabled"));
}

}  // namespace

    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/multipleFiles.kt");
  }

  @Test
  @TestMetadata("simple.kt")
  public void testSimple() {
    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/simple.kt");
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/compilerFacility/compilation/codeFragments")
  @TestDataPath("$PROJECT_ROOT")

// host_compute_core: mapping from outside compilation cluster name to XLA
//   device assignment.
// fld: FunctionLibraryDefinition object.
// host_graph: Graph object to store host side graph for all outside
//   compilations within this XLA computation func. If there is no outside
//   compilation, it will be empty.
// shape_inference_graphs: a list of outside compilation shape inference

        given:
        publishes(multiCoordinateComponent {
            compilation("first")
            compilation("second") {
                attributes = "attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, 'second'))"
                capabilities = "capability('org:other-second:1.0')"
            }
            compilation("third") {

            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        def expectedJvmInterceptors = source """
            package my;
            public class InterceptorDeclaration_GroovyBytecodeImpl {
            }
        """
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)
            .generatedSourceFile(fqName(expectedJvmInterceptors))

// Attribute indicating that this is an IdentityN node receiving inputs for a
// outside compilation Placeholder node (the original outside compilation node
// is moved out of TPU computation, and we left a Placeholder node there).
// Attribute value will be a string, which is the outside compilation cluster
// name for the outside compilation Placeholder node.
extern const char kXlaOutsideCompilationInputsAttrName[];

    def "updates spec for incremental compilation"() {
        def spec = Mock(NativeCompileSpec)
        def newSource = temporaryFolder.file("new")
        def removedSource = temporaryFolder.file("removed")

        def compilation = Mock(IncrementalCompilation)

        when:
        compilation.getRecompile() >> [newSource]
        compilation.getRemoved() >> [removedSource]

        and:

                    return "";
                }
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)
                .generatedFile(CLASS_OUTPUT, "META-INF/gradle/instrumentation/instrumented-classes.txt")

// either unsafe.Sizeof and Alignof, nor runtime, reflect, or reflectlite.

// CommonSize returns sizeof(Type) for a compilation target with a given ptrSize
func CommonSize(ptrSize int) int { return 4*ptrSize + 8 + 8 }

// StructFieldSize returns sizeof(StructField) for a compilation target with a given ptrSize
func StructFieldSize(ptrSize int) int { return 3 * ptrSize }

  constexpr int64_t kDefaultCompilationThreshold = 2;

  // Should allow compilation since this is the first execution.
  profiler->RegisterExecution(function);
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kLazy, 0));

  // Shouldn't allow compilation until compilation has been requested at least
  // kDefaultCompilationThreshold times.
  profiler->RegisterExecution(function);