mlir::cast<FlatSymbolRefAttr>(initializer).getValue());
      RewriteFunction(symbol_table, func);
    }

    // Clean up unused asset ops.
    for (auto asset : llvm::make_early_inc_range(module.getOps<AssetOp>())) {
      if (symbol_table.symbolKnownUseEmpty(asset, module)) {
        asset.erase();
      }
    }
  }

 private:
  // Replaces bounded-input arguments of the function with constant ops in the

@RequiresInstalledToolChain(GCC_COMPATIBLE)
@Requires(UnitTestPreconditions.NotWindows)
class ObjectiveCppPreCompiledHeaderSourcesIntegrationTest extends AbstractNativePreCompiledHeaderIntegrationTest {
    @Override
    IncrementalHelloWorldApp getApp() {
        return new ObjectiveCppHelloWorldApp()
    }

class OutputEventListenerBackedLoggerDefaultConfigurationTest extends Specification {

    @Rule RedirectStdOutAndErr outputs = new RedirectStdOutAndErr()

    String getOut() {
        outputs.stdOut
    }

    String getErr() {
        outputs.stdErr
    }

    def context

    Logger logger() {
        if (context == null) {
            context = new OutputEventListenerBackedLoggerContext(Time.clock())
        }

 public:
  void runOnOperation() override;
};

void InferenceMetricsPass::runOnOperation() {
  bool has_tpu_partitioned_call = false;
  ModuleOp module = getOperation();

  for (auto func_op : module.getOps<func::FuncOp>()) {
    func_op->walk(
        [&](TF::TPUPartitionedCallOp op) { has_tpu_partitioned_call = true; });

    if (has_tpu_partitioned_call) break;
  }

  std::string has_tpu_partitioned_call_str =

        this.repositoryPath = repositoryPath
    }

    @Override
    GcsArtifact getIvy() {
        return new GcsArtifact(server, ivyFile, repositoryPath, bucket)
    }

    @Override
    GcsArtifact getJar() {
        return new GcsArtifact(server, jarFile, repositoryPath, bucket)
    }

    @Override
    ModuleArtifact getModuleMetadata() {
        return new GcsArtifact(server, moduleMetadataFile, repositoryPath, bucket)

        this.repositoryPath = repositoryPath
    }

    @Override
    S3Artifact getIvy() {
        return new S3Artifact(server, ivyFile, repositoryPath, bucket)
    }

    @Override
    S3Artifact getJar() {
        return new S3Artifact(server, jarFile, repositoryPath, bucket)
    }

    @Override
    ModuleArtifact getModuleMetadata() {
        return new S3Artifact(server, moduleMetadataFile, repositoryPath, bucket)

class CppPreCompiledHeaderSourcesIntegrationTest extends AbstractNativePreCompiledHeaderIntegrationTest implements DirectoryBuildCacheFixture {

    @Override
    IncrementalHelloWorldApp getApp() {
        return new CppHelloWorldApp()
    }

    @ToBeFixedForConfigurationCache
    def "caching is disabled if precompiled headers are configured"() {
        writeStandardSourceFiles()

        when:

  }

  return true;
}

TensorArraySideEffectAnalysis::TensorArraySideEffectAnalysis(
    mlir::ModuleOp module) {
  for (auto func_op : module.getOps<mlir::func::FuncOp>()) {
    if (FunctionContainsOnlyNoSideEffectOpOrTensorArrayOp(func_op)) {
      set_.insert(func_op);
    }
  }
}

}  // namespace tfrt_compiler

  // Iterates over all functions within the module to (1) create caller-callee
  // map, and (2) initialize function worklist with functions referenced from
  // device cluster ops.
  for (auto func : module.getOps<func::FuncOp>()) {
    for (auto user : symbol_map.getUsers(func)) {
      // Populate caller-callee map.
      if (func::FuncOp caller = user->getParentOfType<func::FuncOp>())
        caller_callee_map[caller].insert(func);

import org.gradle.nativeplatform.fixtures.app.HelloWorldApp


class AssemblyLanguageParallelIntegrationTest extends AbstractNativeSoftwareModelParallelIntegrationTest {

    @Override
    HelloWorldApp getApp() {
        return new AssemblerWithCHelloWorldApp(toolChain)
    }

    @ToBeFixedForConfigurationCache
    def "can execute assembler tasks in parallel"() {
        given:
        withComponentForApp()