class ElementValueT = typename AttrElementT::ValueType>
Attribute ConstFoldBroadcastInDim(ShapedType result_type,
                                  DenseElementsAttr operand,
                                  DenseIntElementsAttr bcast_dims) {
  auto dimensions = llvm::to_vector(bcast_dims.getValues<int64_t>());
  const auto result_shape = result_type.getShape();
  // Index for the broadcasted matrix.

}

template <typename T>
static inline std::vector<T> GetVector(
    vhlo::TensorV1Attr elements,
    mlir::vhlo::VhloTypeConverter &vhlo_type_converter) {
  return GetOptionalVector<T>(mlir::DenseIntElementsAttr::getFromRawBuffer(
      mlir::cast<mlir::ShapedType>(
          vhlo_type_converter.convertType(elements.getType())),
      elements.getData()));
}

}  // namespace mlir

WhileRegionOp CreateDatasetWhile(OpBuilder builder,
                                 ReduceDatasetOp reduce_dataset) {
  auto const_true = builder.create<TF::ConstOp>(
      reduce_dataset.getLoc(),
      DenseIntElementsAttr::get(
          RankedTensorType::get(/*shape=*/{}, builder.getI1Type()), true));

  SmallVector<Value, 4> while_input_values;
  SmallVector<Type, 4> while_input_types;

  "std::distance($0.use_begin(), $0.use_end()) == 2">>;
def AxesIsLastDimension : Constraint<CPred<
  "$0.cast<DenseIntElementsAttr>().getNumElements() == 1 && "
  "($0.cast<DenseIntElementsAttr>().getValues<APInt>()[0] == "
  "$1.getType().cast<ShapedType>().getRank() - 1 || $0.cast<DenseIntElementsAttr>().getValues<int32_t>()[0] == -1)">>;

// Convert exp(x)/sum(exp(x)) into softmax.
def OptimizeToSoftmax : Pat<

}

// Generate a dummy constant island of requested type.
IslandOp GetDummyConstant(OpBuilder builder, ShapedType const_type,
                          Location loc) {
  DenseIntElementsAttr val = DenseIntElementsAttr::get(const_type, 1);
  auto const_op = builder.create<TF::ConstOp>(loc, val);
  auto const_island = CreateIsland(const_op, {}, builder);
  return const_island;
}

    Operation *tposed_const;
    if (other_input_type.getNumElements() == 1) {
      tposed_const = cst_arg;
    } else {
      auto inverse_perm_attr = DenseIntElementsAttr::get(
          RankedTensorType::get(inverse_perm.size(), rewriter.getI32Type()),
          inverse_perm);
      auto inverse_perm_op =
          rewriter.create<arith::ConstantOp>(perm.getLoc(), inverse_perm_attr);

    return false;

  DenseIntElementsAttr slice_sizes_attr;
  if (DenseIntElementsAttr attr;
      matchPattern(op.getSliceSizes(), m_Constant(&attr))) {
    slice_sizes_attr = attr;
  } else if (const auto it = results_.find(ValuePort(op.getSliceSizes()));
             it != results_.end() &&
             llvm::isa_and_nonnull<DenseIntElementsAttr>(it->second)) {

          return allow_tensorlist_pass_through_
                     ? rewriter.notifyMatchFailure(op, error_info)
                     : op.emitOpError(error_info);
        }
      }
    }

    DenseIntElementsAttr dense_elem_attr;
    if (matchPattern(element_shape, m_Constant(&dense_elem_attr))) {
      // Note: It's technically unsafe to rewrite
      //     TensorListReserve(num_element, element_shape)
      // to

namespace mlir {
namespace TF {
namespace collection_ops_util {

Value CreateScalarConst(int32_t value, OpBuilder builder, Location loc) {
  auto attr = DenseIntElementsAttr::get(
      tensorflow::GetTypeFromTFTensorShape({}, builder.getI32Type()), value);
  return builder.create<TF::ConstOp>(loc, attr);
}

Value GetR1Const(ArrayRef<int64_t> r1, OpBuilder builder, Location loc,

                                  op)))
        return failure();

      OpBuilder builder(op);
      auto const_op = builder.create<TF::ConstOp>(
          op->getLoc(), DenseIntElementsAttr::get(
                            RankedTensorType::get({}, builder.getI64Type()),
                            {device_ordinal}));
      op->replaceAllUsesWith(const_op);
      op->erase();