forward_op_->op_name = op;
  forward_op_->attrs.Reset(op);
  return op_->Reset(op, raw_device_name);
}
absl::Status AddInput(AbstractOperation* op_, AbstractTensorHandle* input,
                      ForwardOperation* forward_op_) {
  TF_RETURN_IF_ERROR(op_->AddInput(input));
  forward_op_->inputs.push_back(input);
  return absl::OkStatus();
}
absl::Status AddInputList(AbstractOperation* op_,

absl::Status Reset(AbstractOperation*, const char* op,
                   const char* raw_device_name, ForwardOperation*);

// Records the inputs in the `ForwardOperation`.
absl::Status AddInput(AbstractOperation*, AbstractTensorHandle*,
                      ForwardOperation*);
absl::Status AddInputList(AbstractOperation*,
                          absl::Span<AbstractTensorHandle* const> inputs,

  if (isa<TracingOperation>(check_numerics_op.get())) {
    s = dyn_cast<TracingOperation>(check_numerics_op.get())
            ->SetOpName("check_numerics");
    ASSERT_EQ(errors::OK, s.code()) << s.message();
  }
  s = AddInput(check_numerics_op.get(), t.get(), &forward_op);
  ASSERT_EQ(errors::OK, s.code()) << s.message();
  string message = "This is the way!";
  s = SetAttrString(check_numerics_op.get(), "message", message.data(),

  //
  // The value will override the previous value - that is, no "merging" of
  // existing and given constraints will be performed.
  virtual absl::Status SetDeviceName(const char* name) = 0;

  virtual absl::Status AddInput(AbstractTensorHandle* input) = 0;
  virtual absl::Status AddInputList(
      absl::Span<AbstractTensorHandle* const> inputs) = 0;
  virtual absl::Status Execute(absl::Span<AbstractTensorHandle*> retvals,

                         TF_AbstractTensor* const* inputs, TF_OutputList* o,
                         TF_Status* s) {
  for (int i = 0; i < num_inputs; i++) {
    tsl::Set_TF_Status_from_Status(s, unwrap(op)->AddInput(unwrap(inputs[i])));
    if (TF_GetCode(s) != TF_OK) {
      return;
    }
  }
  int num_outputs = unwrap(o)->expected_num_outputs;
  tsl::Set_TF_Status_from_Status(
      s, unwrap(op)->Execute(

  absl::Status SetDeviceName(const char* name) override {
    // TODO(srbs): Implement this.
    device_name_ = name;
    return absl::OkStatus();
  }

  absl::Status AddInput(AbstractTensorHandle* input) override {
    GraphTensor* t = dyn_cast<GraphTensor>(input);
    if (!t) {
      return tensorflow::errors::InvalidArgument(
          "Unable to cast input to GraphTensor");
    }

  return tensorflow::unwrap(op)->DeviceName().c_str();
}

void TFE_OpAddInput(TFE_Op* op, TFE_TensorHandle* input, TF_Status* status) {
  status->status = tensorflow::unwrap(op)->AddInput(tensorflow::unwrap(input));
}

void TFE_OpAddInputList(TFE_Op* op, TFE_TensorHandle** inputs, int num_inputs,
                        TF_Status* status) {
  status->status = tensorflow::unwrap(op)->AddInputList(