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()

	reg := typemap.Get[TypeRegistration[T]](registerTypes)
	if reg != nil {
		// This is registered type
		tr := *reg
		return c.Informers().InformerFor(tr.GetGVR(), opts, func() cache.SharedIndexInformer {
			inf := cache.NewSharedIndexInformer(
				tr.ListWatch(c, opts),
				tr.Object(),
				0,
				cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
			)

  const FunctionNameMatcher matcher(spec.matcher().function_name());
  // Iterate over all XlaCallModuleOp in all FuncOps.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    for (auto xla_call_module_op : func.getOps<TF::XlaCallModuleOp>()) {
      if (!matcher.Match(xla_call_module_op)) continue;

      // Set the text representation of `Method` to matched
      // `TF::XlaCallModuleOp`.

  if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module_op)) {
    for (Operation& op : init_func_op.getBody().getOps()) {
      StringRef other_shared_name = GetSharedName(&op);
      if (IsHashTableOp(&op) && other_shared_name == shared_name) {
        return true;
      }
    }
  }
  return false;
}