// Returns a `llvm::DenseMap` which maps from the index of tensorlist in the
// result, to the index of the same tensorlist in the arguments. For `If` op's
// branch functions, the results and arguments are not usually matched 1-1. This
// will let us konw which tensorlist result maps to which tensorlist in the
// arguments. Once we know this info it will help us decide the types of the
// result tensorlist based on the operand's of the `If` op.

  *tensor_proto = TensorProtoHelpers::GenerateTensorProto();

  CreateAndCallKernelWithAttr(my_create_func, "TestKernelAttrTensor", v);
}

TEST_F(TestKernelAttr, TensorList) {
  struct TensorProtoHelpers {
   public:
    static ::tensorflow::TensorProto GenerateTensorProto1() {
      ::tensorflow::TensorProto tensor_proto;
      tensor_proto.mutable_tensor_shape()->add_dim()->set_size(2);

      "return getElementTypeOrSelf(element_type());">;

  let extraClassDeclaration = [{
    // Returns type of the TensorList element produced by this op.
    TensorType element_type() { return handle_dtype().getSubtypes()[0]; }

    // Returns data type of the result handle. Returned type contains type of
    // the TensorList element as a subtype.
    VariantType handle_dtype() {

  LogicalResult matchAndRewrite(Operation *op,
                                PatternRewriter &rewriter) const override {
    auto addn_op = cast<AddNOp>(op);

    // TODO(hinsu): Support variant with TensorList type. tf.AddV2 doesn't
    // support variant type so variant types require special handling.
    if (mlir::isa<VariantType>(getElementTypeOrSelf(addn_op.getType())))
      return failure();

                              TF_TString_GetSize(t_out_tstr)));
  TF_DeleteTensor(t_out);
  TF_TString_Dealloc(&tstr[0]);
}

TEST_F(CApiAttributesTest, TensorList) {
  const char tensor1[] = {5, 7};
  const int64_t dims1[] = {1, 2};
  const size_t ndims1 = TF_ARRAYSIZE(dims1);

  const char tensor2[] = {2, 4, 6, 8};
  const int64_t dims2[] = {2, 2};

  // CHECK: [[tensor_list:%.*]] = "tf.TensorListReserve"([[shape:%.*]], [[reserve_size:%.*]]) {
  %0 = "tf.TensorListReserve"(%cst_1, %cst_2) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<i32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*xf32>>>
  // CHECK: [[map_fn_result:%.*]] = tf_mlrt.tf_map_fn([[reserve_size]], [[tensor_list]], %arg0)

					mg.g.Require(m, append(reqs, vendorMod))
				}
				mg.g.Require(vendorMod, vendorList)

			} else {
				mainModule := MainModules.mustGetSingleMainModule()
				mg.g.Require(mainModule, append(rs.rootModules, vendorMod))
				mg.g.Require(vendorMod, vendorList)
			}
		}

		rs.graph.Store(&cachedGraph{mg, nil})
	})
}

			modFiles = append(modFiles, MainModules.ModFile(m))
			modRoots = append(modRoots, MainModules.ModRoot(m))
		}
		checkVendorConsistency(indexes, modFiles, modRoots)
		rs.initVendor(vendorList)
	}

	if inWorkspaceMode() {
		// We don't need to update the mod file so return early.
		requirements = rs
		return rs, nil
	}

	mainModule := MainModules.mustGetSingleMainModule()