}

static LogicalResult convertTFGlobals(ModuleOp module) {
  OpBuilder globalBuilder(module.getBodyRegion());
  DenseMap<Operation *, std::string> opToName;
  for (auto globalTensor : module.getOps<tf_saved_model::GlobalTensorOp>()) {
    auto exportedNames = tf_saved_model::GetExportedNames(globalTensor);
    std::string name;
    if (exportedNames.empty()) {
      name = "global_ml_" + globalTensor.getSymName().str();

  auto pflr = std::make_unique<ProcessFunctionLibraryRuntime>(
      nullptr, options.session_options->env, /*config=*/nullptr,
      TF_GRAPH_DEF_VERSION, options.flib_def, opts);
  FunctionLibraryRuntime* flr =
      pflr->GetFLR(ProcessFunctionLibraryRuntime::kDefaultFLRDevice);

  for (Node* node : graph->nodes()) {
    if (CanCreateXlaKernel(node->def())) {
      const FunctionBody* fbody = nullptr;
      std::vector<int> constant_arg_indices;

    return failure();
  }

  // Fetch all VarHandleOp.
  llvm::StringSet<> variable_names;
  llvm::SmallVector<TF::VarHandleOp, 4> var_ops;
  for (auto func_op : module.getOps<func::FuncOp>()) {
    for (auto var_handle_op : func_op.getOps<TF::VarHandleOp>()) {
      auto variable_name = GetVariableName(var_handle_op);
      if (variable_names.count(variable_name)) continue;
      var_ops.emplace_back(var_handle_op);

    DefaultGlobalScopedCacheBuilderFactory createGlobalScopedCache(GlobalCacheDir globalCacheDir, UnscopedCacheBuilderFactory unscopedCacheBuilderFactory) {
        return new DefaultGlobalScopedCacheBuilderFactory(globalCacheDir.getDir(), unscopedCacheBuilderFactory);
    }

    @Provides
    IsolatableFactory createIsolatableFactory(
        ClassLoaderHierarchyHasher classLoaderHierarchyHasher,
        ManagedFactoryRegistry managedFactoryRegistry

    public GlobalCacheDir(GradleUserHomeDirProvider userHomeDirProvider) {
        this.globalCacheDir = new File(userHomeDirProvider.getGradleUserHomeDirectory(), GLOBAL_CACHE_DIR_NAME);
    }

    public File getDir() {
        return globalCacheDir;
    }

            return new IsolatedClassLoaderWorkerRequirement(baseDir, projectCacheDir.getDir(), classLoaderStructureProvider.getInProcessClassLoaderStructure(isolatedFromChanges.getAsFiles(), getParamClasses(executionClass, parameters)));
        } else {
            return new FixedClassLoaderWorkerRequirement(baseDir, projectCacheDir.getDir(), Thread.currentThread().getContextClassLoader());
        }
    }

        return new ProjectCacheDir(cacheDir.getDir(), buildOperationRunner, deleter);
    }

    @Provides
    BuildTreeScopedCacheBuilderFactory createBuildTreeScopedCache(ProjectCacheDir projectCacheDir, UnscopedCacheBuilderFactory unscopedCacheBuilderFactory) {
        return new DefaultBuildTreeScopedCacheBuilderFactory(projectCacheDir.getDir(), unscopedCacheBuilderFactory);
    }

    @Provides

                    // create and wire the custom dependencies extension's dependencies to these global configurations
                    api.fromDependencyCollector(getRestricted().getDependencies().getApi());
                    implementation.fromDependencyCollector(getRestricted().getDependencies().getImplementation());
                }
            }
        """

        if (cacheDir.exists() && !cacheDir.isDirectory()) {
            throw new UncheckedIOException(String.format("Cache directory '%s' exists and is not a directory.", cacheDir));
        }
    }

    public File getDir() {
        return cacheDir;
    }

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract ConfigurableFileCollection getFoo()
                @Internal abstract ConfigurableFileCollection getBar()
                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {
                    assert foo.files == layout.files("file1", "file2").files