Support specifying output names during TF_Function creation

PiperOrigin-RevId: 169245946

1 files changed, 171 insertions, 32 deletions

diff --git a/tensorflow/c/c_api_function_test.cc b/tensorflow/c/c_api_function_test.cc
index 88d2f1bd27..8cd910ccbc 100644
--- a/tensorflow/c/c_api_function_test.cc
+++ b/tensorflow/c/c_api_function_test.cc
@@ -149,24 +149,40 @@ class CApiFunctionTest : public ::testing::Test {
   void Define(int num_opers, const std::vector<TF_Operation*>& opers,
               const std::vector<TF_Operation*>& inputs,
               const std::vector<TF_Operation*>& outputs,
-              const char** output_names, bool expect_failure = false) {
+              const std::vector<string>& output_names,
+              bool expect_failure = false) {
     DefineT(num_opers, opers, ToOutput(inputs), ToOutput(outputs), output_names,
             expect_failure);
   }
 
+  // Caller must delete[] the returned value
+  static const char** ToArray(const std::vector<string>& strs) {
+    const char** ptr = nullptr;
+    if (!strs.empty()) {
+      ptr = new const char*[strs.size()];
+      for (size_t i = 0; i < strs.size(); ++i) {
+        ptr[i] = strs[i].c_str();
+      }
+    }
+    return ptr;
+  }
+
   // An explicit `num_opers` is needed so that we can distinguish between the
   // case of no operations specified (-1) and the case of an empty set of
   // operations specified (0).
   void DefineT(int num_opers, const std::vector<TF_Operation*>& opers,
                const std::vector<TF_Output>& inputs,
-               const std::vector<TF_Output>& outputs, const char** output_names,
+               const std::vector<TF_Output>& outputs,
+               const std::vector<string>& output_names,
                bool expect_failure = false) {
     ASSERT_EQ(func_, nullptr);
+    const char** output_names_ptr = ToArray(output_names);
     func_ = TF_GraphToFunction(func_graph_, func_name_, num_opers,
                                num_opers == -1 ? nullptr : opers.data(),
                                inputs.size(), inputs.data(), outputs.size(),
-                               outputs.data(), output_names,
+                               outputs.data(), output_names_ptr,
                                /*opts=*/nullptr, s_);
+    delete[] output_names_ptr;
     if (expect_failure) {
       ASSERT_EQ(func_, nullptr);
       return;
@@ -357,7 +373,7 @@ TEST_F(CApiFunctionTest, OneOp_ZeroInputs_OneOutput) {
    */
   // Define
   TF_Operation* c = ScalarConst(10, func_graph_, s_, "scalar10");
-  Define(-1, {}, {}, {c}, nullptr);
+  Define(-1, {}, {}, {c}, {});
 
   // Use, run, and verify
   TF_Operation* func_op = Use({});
@@ -377,7 +393,7 @@ TEST_F(CApiFunctionTest, OneOp_OneInput_OneOutput) {
   // Define
   TF_Operation* feed = Placeholder(func_graph_, s_);
   TF_Operation* neg = Neg(feed, func_graph_, s_);
-  Define(-1, {}, {feed}, {neg}, nullptr);
+  Define(-1, {}, {feed}, {neg}, {});
 
   // Use, run, and verify
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
@@ -387,6 +403,48 @@ TEST_F(CApiFunctionTest, OneOp_OneInput_OneOutput) {
              {{"feed", "neg_0:0"}, {"neg_0:y:0", "neg"}}, {});
 }
 
+TEST_F(CApiFunctionTest, OneOutput_OutputNames) {
+  /*
+   *                   |
+   *                   v
+   *                 negate
+   *                   |
+   *                   v
+   */
+  // Define
+  TF_Operation* feed = Placeholder(func_graph_, s_);
+  TF_Operation* neg = Neg(feed, func_graph_, s_);
+  Define(-1, {}, {feed}, {neg}, {"negated_num"});
+
+  // Use, run, and verify
+  TF_Operation* func_feed = Placeholder(host_graph_, s_);
+  TF_Operation* func_op = Use({func_feed});
+  Run({{func_feed, Int32Tensor(3)}}, func_op, -3);
+  VerifyFDef({"neg"}, {{"feed", DT_INT32}}, {{"negated_num", DT_INT32}},
+             {{"feed", "neg:0"}, {"neg:y:0", "negated_num"}}, {});
+}
+
+TEST_F(CApiFunctionTest, OutputNames_SameNameAsInput) {
+  /*
+   *                   |
+   *                   v
+   *                 negate
+   *                   |
+   *                   v
+   */
+  // Define
+  TF_Operation* feed = Placeholder(func_graph_, s_, "negation");
+  TF_Operation* neg = Neg(feed, func_graph_, s_, "neg");
+  Define(-1, {}, {feed}, {neg}, {"negation"});
+
+  // Use, run, and verify
+  TF_Operation* func_feed = Placeholder(host_graph_, s_);
+  TF_Operation* func_op = Use({func_feed});
+  Run({{func_feed, Int32Tensor(3)}}, func_op, -3);
+  VerifyFDef({"neg"}, {{"negation_0", DT_INT32}}, {{"negation", DT_INT32}},
+             {{"negation_0", "neg:0"}, {"neg:y:0", "negation"}}, {});
+}
+
 TEST_F(CApiFunctionTest, ZeroOps_Identity) {
   /*
    *                   |
@@ -396,14 +454,14 @@ TEST_F(CApiFunctionTest, ZeroOps_Identity) {
    */
   // Define
   TF_Operation* feed = Placeholder(func_graph_, s_);
-  Define(-1, {}, {feed}, {feed}, nullptr);
+  Define(-1, {}, {feed}, {feed}, {});
 
   // Use, run, and verify
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
   TF_Operation* func_op = Use({func_feed});
   Run({{func_feed, Int32Tensor(3)}}, func_op, 3);
-  VerifyFDef(empty_, {{"feed", DT_INT32}}, {{"feed_0", DT_INT32}},
-             {{"feed", "feed_0"}}, {});
+  VerifyFDef(empty_, {{"feed_0", DT_INT32}}, {{"feed", DT_INT32}},
+             {{"feed_0", "feed"}}, {});
 }
 
 TEST_F(CApiFunctionTest, ZeroOps_Permutation) {
@@ -420,15 +478,40 @@ TEST_F(CApiFunctionTest, ZeroOps_Permutation) {
   // Define
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
-  Define(-1, {}, {feed1, feed2}, {feed2, feed1}, nullptr);
+  Define(-1, {}, {feed1, feed2}, {feed2, feed1}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_);
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
   TF_Operation* func_op = Use({two, func_feed});
   Run({{func_feed, Int32Tensor(3)}}, {{func_op, 0}, {func_op, 1}}, {3, 2});
-  VerifyFDef(empty_, M({{"feed1"}, {"feed2"}}), M({{"feed2_0"}, {"feed1_0"}}),
-             {{"feed1", "feed1_0"}, {"feed2", "feed2_0"}}, {});
+  VerifyFDef(empty_, M({{"feed1_0"}, {"feed2_0"}}), M({{"feed2"}, {"feed1"}}),
+             {{"feed1_0", "feed1"}, {"feed2_0", "feed2"}}, {});
+}
+
+TEST_F(CApiFunctionTest, ZeroOps_Permutation_OutputNames) {
+  /*
+   *                   |   |
+   *                   \  /
+   *                    \/
+   *                    x
+   *                   /\
+   *                  /  \
+   *                 |   |
+   *                 v   v
+   */
+  // Define
+  TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
+  TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
+  Define(-1, {}, {feed1, feed2}, {feed2, feed1}, {"first", "second"});
+
+  // Use, run, and verify
+  TF_Operation* two = ScalarConst(2, host_graph_, s_);
+  TF_Operation* func_feed = Placeholder(host_graph_, s_);
+  TF_Operation* func_op = Use({two, func_feed});
+  Run({{func_feed, Int32Tensor(3)}}, {{func_op, 0}, {func_op, 1}}, {3, 2});
+  VerifyFDef(empty_, M({{"feed1"}, {"feed2"}}), M({{"first"}, {"second"}}),
+             {{"feed1", "second"}, {"feed2", "first"}}, {});
 }
 
 TEST_F(CApiFunctionTest, OneOp_TwoInputs_OneOutput) {
@@ -443,7 +526,7 @@ TEST_F(CApiFunctionTest, OneOp_TwoInputs_OneOutput) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  Define(-1, {}, {feed1, feed2}, {add}, nullptr);
+  Define(-1, {}, {feed1, feed2}, {add}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_);
@@ -467,7 +550,7 @@ TEST_F(CApiFunctionTest, OneOp_TwoInputs_ZeroOutputs) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   Add(feed1, feed2, func_graph_, s_);
-  Define(-1, {}, {feed1, feed2}, {}, nullptr);
+  Define(-1, {}, {feed1, feed2}, {}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_);
@@ -494,7 +577,7 @@ TEST_F(CApiFunctionTest, TwoOps_ThreeInputs_OneOutput) {
   TF_Operation* feed3 = Placeholder(func_graph_, s_, "feed3");
   TF_Operation* add1 = Add(feed1, feed2, func_graph_, s_, "add1");
   TF_Operation* add2 = Add(add1, feed3, func_graph_, s_, "add2");
-  Define(-1, {}, {feed1, feed2, feed3}, {add2}, nullptr);
+  Define(-1, {}, {feed1, feed2, feed3}, {add2}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_, "two");
@@ -526,7 +609,7 @@ TEST_F(CApiFunctionTest, OneOp_TwoInputs_TwoDuplicateOutputs) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  Define(-1, {}, {feed1, feed2}, {add, add}, nullptr);
+  Define(-1, {}, {feed1, feed2}, {add, add}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_);
@@ -541,6 +624,35 @@ TEST_F(CApiFunctionTest, OneOp_TwoInputs_TwoDuplicateOutputs) {
              {});
 }
 
+TEST_F(CApiFunctionTest, TwoDuplicateOutputs_OutputNames) {
+  /*
+   *                  |  |
+   *                  v  v
+   *                  add
+   *                   |
+   *                 +-+-+
+   *                 |   |
+   *                 v   v
+   */
+  // Define
+  TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
+  TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
+  TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
+  Define(-1, {}, {feed1, feed2}, {add, add}, {"out1", "out2"});
+
+  // Use, run, and verify
+  TF_Operation* two = ScalarConst(2, host_graph_, s_);
+  TF_Operation* func_feed = Placeholder(host_graph_, s_);
+  TF_Operation* func_op = Use({two, func_feed});
+  Run({{func_feed, Int32Tensor(3)}}, {{func_op, 0}, {func_op, 1}}, {5, 5});
+  VerifyFDef({"add"}, M({{"feed1"}, {"feed2"}}), M({{"out1"}, {"out2"}}),
+             {{"feed1", "add:0"},
+              {"feed2", "add:1"},
+              {"add:sum:0", "out1"},
+              {"add:sum:0", "out2"}},
+             {});
+}
+
 TEST_F(CApiFunctionTest, TwoOps_ThreeInputs_TwoOutputs) {
   /*
    *                  |  |  |
@@ -560,7 +672,7 @@ TEST_F(CApiFunctionTest, TwoOps_ThreeInputs_TwoOutputs) {
   TF_Operation* feed3 = Placeholder(func_graph_, s_, "feed3");
   TF_Operation* add1 = Add(feed1, feed2, func_graph_, s_, "add1");
   TF_Operation* add2 = Add(add1, feed3, func_graph_, s_, "add2");
-  Define(-1, {}, {feed1, feed2, feed3}, {add1, add2}, nullptr);
+  Define(-1, {}, {feed1, feed2, feed3}, {add1, add2}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_, "two");
@@ -600,7 +712,7 @@ TEST_F(CApiFunctionTest, FromSubsetOfOps) {
   TF_Operation* feed3 = Placeholder(func_graph_, s_, "feed3");
   TF_Operation* add1 = Add(feed1, feed2, func_graph_, s_, "add1");
   TF_Operation* add2 = Add(add1, feed3, func_graph_, s_, "add2");
-  Define(1, {add2}, {add1, feed3}, {add2}, nullptr);
+  Define(1, {add2}, {add1, feed3}, {add2}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_, "two");
@@ -634,7 +746,7 @@ TEST_F(CApiFunctionTest, UsingOneOutputOfSplit) {
   // Define
   TF_Operation* feed = Placeholder(func_graph_, s_);
   TF_Operation* split = Split3(feed, func_graph_, s_);
-  DefineT(-1, {}, {{feed, 0}}, {{split, 1}}, nullptr);
+  DefineT(-1, {}, {{feed, 0}}, {{split, 1}}, {});
 
   // Use, run, and verify
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
@@ -669,7 +781,7 @@ TEST_F(CApiFunctionTest, UsingTwoOutputsOfSplit) {
   // Define
   TF_Operation* feed = Placeholder(func_graph_, s_);
   TF_Operation* split = Split3(feed, func_graph_, s_);
-  DefineT(-1, {}, {{feed, 0}}, {{split, 0}, {split, 2}}, nullptr);
+  DefineT(-1, {}, {{feed, 0}}, {{split, 0}, {split, 2}}, {});
 
   // Use, run, and verify
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
@@ -708,7 +820,7 @@ TEST_F(CApiFunctionTest, UsingTwoOutputsOfSplitAsInputs) {
   TF_Operation* split = Split3(feed, func_graph_, s_);
   TF_Operation* add = Add({split, 0}, {split, 2}, func_graph_, s_);
   ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
-  DefineT(1, {add}, {{split, 0}, {split, 2}}, {{add, 0}}, nullptr);
+  DefineT(1, {add}, {{split, 0}, {split, 2}}, {{add, 0}}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_, "two");
@@ -744,7 +856,7 @@ TEST_F(CApiFunctionTest, NodesUsedInInputsMustHaveSingleOutput) {
   TF_Operation* split = Split3(c, func_graph_, s_);
   TF_Operation* add = Add({split, 0}, {split, 2}, func_graph_, s_);
   ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
-  DefineT(-1, {}, {{split, 0}, {split, 2}}, {{add, 0}}, nullptr, true);
+  DefineT(-1, {}, {{split, 0}, {split, 2}}, {{add, 0}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("When `num_opers` is set to -1, nodes referenced in "
                    "`inputs` must have a single output. Node split3 has "
@@ -797,7 +909,7 @@ TEST_F(CApiFunctionTest, FunctionWithWhileLoop) {
   }
 
   // Define function, use it in graph, and run
-  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {outputs[0]}, nullptr);
+  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {outputs[0]}, {});
   TF_Operation* five = ScalarConst(5, host_graph_, s_, "five");
   TF_Operation* func_feed = Placeholder(host_graph_, s_);
   TF_Operation* func_op = Use({func_feed, five});
@@ -835,7 +947,7 @@ TEST_F(CApiFunctionTest, ControlDependency) {
   TF_Operation* add =
       AddWithCtrlDependency(feed1, feed2, func_graph_, five, s_);
   EXPECT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
-  Define(-1, {}, {feed1, feed2}, {add}, nullptr);
+  Define(-1, {}, {feed1, feed2}, {add}, {});
 
   // Use, run, and verify
   TF_Operation* two = ScalarConst(2, host_graph_, s_);
@@ -864,7 +976,7 @@ TEST_F(CApiFunctionTest, ControlDependencyOutsideOfBody) {
   TF_Operation* add =
       AddWithCtrlDependency(feed1, feed2, func_graph_, five, s_);
   EXPECT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
-  Define(1, {add}, {feed1, feed2}, {add}, nullptr, true);
+  Define(1, {add}, {feed1, feed2}, {add}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("The source of control edge [id=3 scalar:-1 -> add:-1] "
                    "is not in the body. Encountered while creating "
@@ -888,7 +1000,7 @@ TEST_F(CApiFunctionTest, ControlDependencyOutsideOfBody_FromInputNode) {
   TF_Operation* add =
       AddWithCtrlDependency(feed1, feed2, func_graph_, feed1, s_);
   EXPECT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);
-  Define(-1, {}, {feed1, feed2}, {add}, nullptr, true);
+  Define(-1, {}, {feed1, feed2}, {add}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("The source of control edge [id=3 feed1:-1 -> add:-1] "
                    "is not in the body. Encountered while creating "
@@ -914,13 +1026,40 @@ TEST_F(CApiFunctionTest, DuplicateInputsAreNotAllowed) {
    */
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* add = Add(feed1, feed1, func_graph_, s_);
-  Define(-1, {}, {feed1, feed1}, {add}, nullptr, true);
+  Define(-1, {}, {feed1, feed1}, {add}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(
       string("TF_Output feed1:0 appears more than once in the input list"),
       string(TF_Message(s_)));
 }
 
+TEST_F(CApiFunctionTest, DuplicateOutputNamesAreNotAllowed) {
+  /*
+   *                  |  |  |
+   *                  v  v  /
+   *                  add  /
+   *                   |  |
+   *                 +-+  |
+   *                 | |  |
+   *                 | v  v
+   *                 | add
+   *                 |  |
+   *                 v  v
+   */
+  // Define
+  TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
+  TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
+  TF_Operation* feed3 = Placeholder(func_graph_, s_, "feed3");
+  TF_Operation* add1 = Add(feed1, feed2, func_graph_, s_, "add1");
+  TF_Operation* add2 = Add(add1, feed3, func_graph_, s_, "add2");
+  Define(-1, {}, {feed1, feed2, feed3}, {add1, add2}, {"my_out", "my_out"},
+         true);
+  EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
+  EXPECT_EQ(string("Cannot have duplicate output names. Name 'my_out' "
+                   "appears more than once in 'output_names' array."),
+            string(TF_Message(s_)));
+}
+
 TEST_F(CApiFunctionTest, InvalidInputTensor_HighIndex) {
   /*
    *                  |  |
@@ -932,7 +1071,7 @@ TEST_F(CApiFunctionTest, InvalidInputTensor_HighIndex) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  DefineT(-1, {}, {{feed1, 0}, {feed2, 2}}, {{add, 0}}, nullptr, true);
+  DefineT(-1, {}, {{feed1, 0}, {feed2, 2}}, {{add, 0}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("Node 'feed2' (type: 'Placeholder', num of outputs: 1) does "
                    "not have output 2\n\tEncountered while processing "
@@ -951,7 +1090,7 @@ TEST_F(CApiFunctionTest, InvalidInputTensor_BadNodePtr) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  DefineT(-1, {}, {{feed1, 0}, {nullptr, 0}}, {{add, 0}}, nullptr, true);
+  DefineT(-1, {}, {{feed1, 0}, {nullptr, 0}}, {{add, 0}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("Node is null\n\tEncountered while processing input 1 "
                    "into function 'MyFunc'"),
@@ -969,7 +1108,7 @@ TEST_F(CApiFunctionTest, InvalidOutputTensor_HighIndex) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {{add, 3}}, nullptr, true);
+  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {{add, 3}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("Node 'add' (type: 'AddN', num of outputs: 1) does "
                    "not have output 3\n\tEncountered while processing "
@@ -988,7 +1127,7 @@ TEST_F(CApiFunctionTest, InvalidOutputTensor_BadNodePtr) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   Add(feed1, feed2, func_graph_, s_);
-  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {{nullptr, 3}}, nullptr, true);
+  DefineT(-1, {}, {{feed1, 0}, {feed2, 0}}, {{nullptr, 3}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("Node is null\n\tEncountered while processing output 0 "
                    "from function 'MyFunc'"),
@@ -1006,7 +1145,7 @@ TEST_F(CApiFunctionTest, NodeMissingInput) {
   TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  DefineT(1, {add}, {{feed1, 0}}, {{add, 0}}, nullptr, true);
+  DefineT(1, {add}, {{feed1, 0}}, {{add, 0}}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("Input 1, 'feed2:0', of node 'add' in function 'MyFunc' "
                    "is not available. You might need to include it in inputs "
@@ -1027,7 +1166,7 @@ TEST_F(CApiFunctionTest, OutputOpNotInBody) {
   TF_Operation* feed2 = Placeholder(func_graph_, s_, "feed2");
   TF_Operation* scalar = ScalarConst(2, func_graph_, s_);
   TF_Operation* add = Add(feed1, feed2, func_graph_, s_);
-  Define(1, {add}, {feed1, feed2}, {add, scalar}, nullptr, true);
+  Define(1, {add}, {feed1, feed2}, {add, scalar}, {}, true);
   EXPECT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
   EXPECT_EQ(string("TF_Output scalar:0 is neither in the function body nor "
                    "among function inputs. Encountered while creating "