}
}

}  // namespace

bool IsQuantized(const TensorT& tensor) {
  return (tensor.quantization != nullptr) &&
         !tensor.quantization->zero_point.empty();
}

// Returns the correct type for a quantized tensor.
// We have a special case for constants since they have a higher minimum value.
StatusOr<QuantizedType> GetQuantizedType(const TensorT& tensor, Builder builder,

  DataType data_type() const { return data_type_; }
  Status status() const { return status_; }
  const Tensor& tensor() const { return tensor_; }

 private:
  Status status_;
  Output output_ = Output(Operation(nullptr), 0);
  Tensor tensor_;
  const std::string node_name_ = "";
  int32 index_ = 0;
  DataType data_type_ = DT_INVALID;
};

    auto* ret = emptyTensor->tensor;
    delete emptyTensor;
    return ret;
  }

  Tensor tensor;
  if (!tensor.CopyFrom(src, src.shape())) {
    return nullptr;
  }
  return new tensorflow::TensorInterface(std::move(tensor));
}

// Non-static for testing.
TF_Tensor* TF_TensorFromTensor(const tensorflow::Tensor& src, Status* status) {

def PromiseOp: TensorflowMlrt_Op<"promise", []> {
  let summary = "Set a tensor in a promise";

  let description = [{
    Set a tensor in a promise.

    $promise: A value of type !mlrt.promise. The underlying value must be a tensorflow tensor.
    $tensor: A tensorflow tensor.
  }];

  let arguments = (ins
    MlrtPromiseType:$promise,
    TFTensorType:$tensor
  );

  let assemblyFormat = "operands attr-dict";
}

// as tensor names may have changed via MLIR constant folding process.
bool ExpectEqualTensor(const Tensor* tensor, const Tensor* expected_tensor) {
  return (tensor->is_variable() == expected_tensor->is_variable()) &&
         (GetAsVector(tensor->shape()) ==
          GetAsVector(expected_tensor->shape()));
}

// Finds the match of the quantized tensor from the possible tensors. Each

      });
}
bool Tape::ShouldRecord(
    absl::Span<const AbstractTensorHandle* const> tensors) const {
  std::vector<int64_t> tensor_ids(tensors.size());
  std::vector<tensorflow::DataType> tensor_dtypes(tensors.size());
  for (int i = 0; i < tensors.size(); i++) {
    tensor_ids[i] = ToId(tensors[i]);
    tensor_dtypes[i] = tensors[i]->DataType();
  }
  return GradientTape::ShouldRecord(tensor_ids, tensor_dtypes);
}

    [Pure, CoreRT_TypedAttributeTrait,
     TFRT_CostFunctionInterface, TFRT_FixedCost<1>]> {
  let summary = "Create a tensorflow tensor from serialized tensor proto";

  let description = [{
    Create a tensorflow tensor from serilaized tensor proto.

    Example:
      %tensor = tfrt_fallback_async.const_tensor_proto "<serialized proto content>"
  }];

  let arguments = (ins
    StrAttr:$serialized_tensor_proto

// model.
table SubGraph {
  // A list of all tensors used in this subgraph.
  tensors:[Tensor];

  // Indices of the tensors that are inputs into this subgraph. Note this is
  // the list of non-static tensors that feed into the subgraph for inference.
  inputs:[int];

  // Indices of the tensors that are outputs out of this subgraph. Note this is
  // the list of output tensors that are considered the product of the

// model.
table SubGraph {
  // A list of all tensors used in this subgraph.
  tensors:[Tensor];

  // Indices of the tensors that are inputs into this subgraph. Note this is
  // the list of non-static tensors that feed into the subgraph for inference.
  inputs:[int];

  // Indices of the tensors that are outputs out of this subgraph. Note this is
  // the list of output tensors that are considered the product of the

    }

    tensors.emplace_back(
        device_->GetAllocator(tensorflow::AllocatorAttributes()), expr.dtype(),
        shape_or.value());

    tensorflow::Tensor& tensor = tensors.back();
    tensorflow::XlaExpression::AssignExpressionToTensor(expr, &tensor);
    inputs.emplace_back(&tensor);
  }

  return success();
}