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

      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.

                                 NodeDef* node_def) {
  const NameAttrList* name_attr;
  TF_RETURN_IF_ERROR(GetNodeAttr(node.attrs(), attr_name, &name_attr));
  node_def->set_op(name_attr->name());
  *(node_def->mutable_attr()) = name_attr->attr();
  return absl::OkStatus();
}

absl::StatusOr<std::vector<NodeDef>> MakeCallNodesFromAttribute(
    const Node& node, absl::string_view attr_name,

  std::vector<NodeAndType> nodes;
  for (auto& node : graph.node_def()) {
    nodes.push_back({node.op(), node.attr().at("T").type()});
  }
  return nodes;
}

TEST_F(TFRDecomposeContextTest, FLOAT_1_ins) {
  std::vector<NodeDefBuilder::NodeOut> src_list;
  src_list.emplace_back("input", 0, DT_FLOAT);
  NodeDef test_node;
  auto status = NodeDefBuilder("float_add", "MyAddN")

    if (stateless && stateless.getValue())
      *node_def->mutable_op() = "Stateless" + node_def->op();
  }

  // Add inputs to the NodeDef based on the number of operands. This is required
  // as later when edges are added to the Node using Graph::AddEdge the
  // associated NodeDef is not updated.
  for (int i = 0, e = inst->getNumOperands(); i < e; ++i) {
    node_def->add_input();
  }

// ShapedType for the leading values with ShapedType in the results of the
// nodes. Set it to true if the returned NodeDef will be executed by the linked
// TF Eager runtime.
absl::StatusOr<std::unique_ptr<NodeDef>> ConvertTFDialectOpToNodeDef(
    mlir::Operation* inst, llvm::StringRef name,
    bool ignore_unregistered_attrs);

}  // namespace tensorflow

      StringRef custom_options, Location loc, std::string& op_name,
      SmallVectorImpl<NamedAttribute>& attributes,
      tensorflow::NodeDef& node_def) {
    // The flexbuffer contains a vector where the first elements is the
    // op name and the second is a serialized NodeDef.
    const uint8_t* const opt_data =
        reinterpret_cast<const uint8_t*>(custom_options.data());
    const size_t opt_size = custom_options.size();

bool HasLiftedArgs(const FunctionDef& function_def) {
  return absl::c_any_of(function_def.node_def(), [](const NodeDef& node_def) {
    return (node_def.op() == "Placeholder" &&
            node_def.attr().find(kXlaLiftedArgOutsideCompilationAttrName) !=
                node_def.attr().end());
  });
}

// Find lifted arguments in a function body and their corresponding outside
// compilation nodes.

                                       node_def->mutable_attr()));

  return node_def;
}

absl::StatusOr<std::unique_ptr<NodeDef>> Exporter::GetReturnNode(
    FuncOp function, Value operand, unsigned index, llvm::StringRef name) {
  auto node_def = std::make_unique<NodeDef>();
  if (!name.empty())
    node_def->set_name(std::string(ParseTensorName(name.str()).node()));
  else