const NameAttrList& function,
                                       bool has_ref_vars)
    : AsyncOpKernel(ctx),
      constants_(constants),
      resources_(resources),
      function_(function),
      platform_info_(XlaPlatformInfoFromDevice(ctx->device())),
      has_ref_vars_(has_ref_vars) {}

void XlaLocalLaunchBase::ComputeAsync(OpKernelContext* ctx, DoneCallback done) {

    bool has_ref_vars, bool may_alias_resource_update) {
  XlaCompiler::CompileOptions compile_options;
  compile_options.is_entry_computation = true;
  // Optimization: where possible, have the computation return a naked array
  // rather than a one-element tuple.
  compile_options.always_return_tuple = false;
  compile_options.alias_resource_update =
      !has_ref_vars && may_alias_resource_update;

      **xla_device_compiler, *ctx->function_library(), ctx->device(),
      ctx->op_device_context() ? ctx->op_device_context()->stream() : nullptr,
      platform_info_, /*has_ref_vars=*/true);
  // No detailed logging from on demand op.
  options.detailed_logging = false;
  XlaCompiler::CompileOptions compile_options = GetCompileOptions();

  return (*xla_device_compiler)

  EncapsulateSubgraphsPass pass;
  TF_ASSERT_OK(pass.Run(options));

  for (const Node* node : graph->nodes()) {
    bool has_ref_var;
    TF_ASSERT_OK(
        GetNodeAttr(node->attrs(), kXlaHasReferenceVarsAttr, &has_ref_var));
    EXPECT_TRUE(node->IsSink() || node->IsSource() || has_ref_var)
        << "All nodes apart from source and sink can access reference variable";
  }
}

                      GetNodesRelatedToRefVariables(**options.graph, flr));
  for (Node* node : (*options.graph)->nodes()) {
    bool has_ref_vars = ref_related_nodes.contains(node);
    node->AddAttr(kXlaHasReferenceVarsAttr, has_ref_vars);
    VLOG(3) << "Has ref vars = " << has_ref_vars
            << ", node: " << node->def().DebugString();
  }
  return absl::OkStatus();
}

  } else {
    options = GenerateCompilerOptions(*xla_device_compiler, *flr, dev, stream,
                                      platform_info,
                                      /*has_ref_vars=*/false);
  }

  return CompileAndBuildHLOString(stage, options, xla_device_compiler->client(),
                                  function, args);
}

absl::StatusOr<std::string> GetCompilerIr(