void MutateNodeDefs(tensorflow::GraphDef& graph_def, FuncT&& func) {
  for (tensorflow::NodeDef& node_def : *graph_def.mutable_node()) {
    func(node_def);
  }

  for (tensorflow::FunctionDef& function_def :
       *graph_def.mutable_library()->mutable_function()) {
    for (tensorflow::NodeDef& node_def : *function_def.mutable_node_def()) {
      func(node_def);
    }
  }
}

  MutateNodeDefs(graph_def,
                 [](NodeDef& node_def) { node_def.set_name("bar"); });

  ASSERT_THAT(graph_def.library().function(), SizeIs(1));
  ASSERT_THAT(graph_def.library().function()[0].node_def(), SizeIs(1));
  EXPECT_THAT(graph_def.library().function()[0].node_def()[0].name(),
              StrEq("bar"));
}

}  // namespace

          }
        }
      }
    }
  }

  // Upgrade nodes in the GraphDef.
  for (auto& node_def : *gdef.mutable_node()) {
    const OpDef* op_def = nullptr;
    TF_RETURN_IF_ERROR(flib_def->LookUpOpDef(node_def.op(), &op_def));
    // TODO(b/197144710): improve the shared_name attr, each op may use the
    // shared_name differently.

  return CanCreateXlaKernel(props->node_def) &&
         !XlaOpRegistry::IsCompilationDevice(flr.device()->device_type());
}

static Status CreateXlaKernel(FunctionLibraryRuntime* flr,
                              const NodeDef& node_def,
                              std::unique_ptr<OpKernel>* kernel) {
  if (!CanCreateXlaKernel(node_def)) {
    return errors::Internal("Invalid node: ", node_def.ShortDebugString());
  }

absl::StatusOr<FunctionDef> TFRDecomposeContext::ExpandNode(
    const NodeDef& node_def, StringPiece func_name) {
  const OpDef* op_def;
  TF_RETURN_IF_ERROR(OpRegistry::Global()->LookUpOpDef(node_def.op(), &op_def));
  DataTypeVector input_dtys, output_dtys;
  TF_RETURN_IF_ERROR(InputTypesForNode(node_def, *op_def, &input_dtys));
  TF_RETURN_IF_ERROR(OutputTypesForNode(node_def, *op_def, &output_dtys));

      StringPiece tfr_raw_text, mlir::MLIRContext* mlir_ctx);

  // Decomposes the op in the NodeDef to a set of primitive ops according to the
  // decompose library in the context. Wrap the decomposed result in a
  // FunctionDef.
  absl::StatusOr<FunctionDef> ExpandNode(const NodeDef& node_def,
                                         StringPiece func_name);

  // Runs the decompose passes on the user_module.

  absl::StatusOr<OpKernelRunner> runner = OpKernelRunner::Create(
      node_def->get()->op(), node_def->get()->name(), host_cpu, operands.size(),
      [&](tensorflow::AttrValueMap* attr_value_map) {
        *attr_value_map = node_def->get()->attr();
        return absl::OkStatus();
      },
      fallback_state.device_manager(),

  }
  auto node_def_or = ConvertTFDialectOpToNodeDef(
      inst, node_name.c_str(), /*ignore_unregistered_attrs=*/true);
  RETURN_FAILURE_IF_ERROR(node_def_or.status());
  const auto& node_def = node_def_or.value();

  TFE_Op* op = TFE_NewOp(context, node_def->op().c_str(), status);
  RETURN_FAILURE_IF_ERROR(status);
  auto clean_op = MakeCleanup([op] { TFE_DeleteOp(op); });

  kUncompiled,
  kCompiling,
  kCompiled,
};

// Creates a single-node graph using the specified `node_def` as the only op
// apart from the arg and retval nodes corresponding to `args` and
// `result_types` respectively.
absl::StatusOr<std::unique_ptr<Graph>> CreateSingleOpGraph(
    const NodeDef& node_def, absl::Span<const XlaArgument> args,
    absl::Span<const DataType> result_types);

  op: "bar"
  experimental_debug_info {
  }
}
library {
  function {
    signature {
      name: "bar"
    }
  }
  function {
    signature {
      name: "foo"
    }
    node_def {
      name: "unnamed"
      op: "bar"
      experimental_debug_info {
        original_node_names: "unnamed"
      }
    }
  }
}
versions {
  producer: 29
  min_consumer: 12
}