mlir::IntegerAttr op_key;
  mlir::IntegerAttr cost;
  mlir::StringAttr device;
  mlir::StringAttr op_name;
  mlir::SymbolRefAttr f;
  llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand, 4> in_chains;
  llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand, 4> operands;
  mlir::NamedAttrList op_attrs;
  mlir::NamedAttrList op_func_attrs;
  auto loc = parser.getNameLoc();

  if (options.has_chain &&

    parsed_devices->push_back(parsed_name);
  }
  return true;
}

using DeviceNames = llvm::SmallVector<std::string, 8>;

struct ParameterizedDeviceSetTest
    : ::testing::TestWithParam<std::tuple<DeviceNames, std::string>> {};

TEST_P(ParameterizedDeviceSetTest, BadDeviceSet) {
  llvm::SmallVector<Device, 8> devices;
  ASSERT_TRUE(DeviceNamesToParsedNames(std::get<0>(GetParam()), &devices));
  std::string topology_attr;

#include "llvm/ADT/SmallVector.h"

namespace tensorflow {

llvm::SmallVector<int64_t> ConvertTFShapeToMlir(
    llvm::ArrayRef<int64_t> shapes) {
  return llvm::to_vector(llvm::map_range(shapes, [](int64_t shape) {
    return shape == kTFDynamicSize ? mlir::ShapedType::kDynamic : shape;
  }));
}

llvm::SmallVector<int64_t> ConvertMlirShapeToTF(
    llvm::ArrayRef<int64_t> shapes) {

    // Compute ConvDimensionNumbers, dilation, and padding.
    SmallVector<int64_t, num_spatial_dims> spatial_dims;
    SmallVector<int64_t, num_spatial_dims> kernel_spatial_dims;
    SmallVector<int64_t, num_spatial_dims> rhs_dilation;
    SmallVector<int64_t, num_spatial_dims * 2> paddings;
    SmallVector<int64_t, num_spatial_dims> window_strides;

// bytes that represent host endianness values.
// The read_size parameter is present to allow reading both float16 and float32
// without a case split.
template <typename T>
llvm::SmallVector<mlir::APInt> ReadAsHostEndian(ArrayRef<uint8_t> bytes) {
  llvm::SmallVector<mlir::APInt> ret;
  size_t read_size = sizeof(T);
  int bytes_len = bytes.size();
  assert(bytes_len % read_size == 0);

  int elem_count = bytes_len / read_size;

  MLIRContext* context = backprop.getContext();
  SmallVector<int64_t, 4> values = {1, 1, 1, 1};
  auto attrs = llvm::map_range(values, [context](int64_t v) -> Attribute {
    return IntegerAttr::get(IntegerType::get(context, 64), APInt(64, v));
  });
  auto strides = ArrayAttr::get(context, llvm::to_vector<4>(attrs));

  // new result type.
  SmallVector<int64_t, 4> new_shape(new_filter_shape.begin(),

 private:
  // Collects all candidate ops for quantization, which are the
  // `dequantize_op`'s users.
  FailureOr<SmallVector<Operation*>> CollectCandidateOps(
      DequantizeOpT dequantize_op) const {
    auto users = dequantize_op->getResult(0).getUsers();
    return SmallVector<Operation*>(users.begin(), users.end());
  }

  // Collects all candidate ops for quantization, which is the operand of

  SmallVector<NamedAttribute> attributes;
  return LiftAsFunctionCall(builder, location, call_op_type, func_name,
                            arguments, results, attributes);
}

SmallVector<Value> AppendToVector(const ArrayRef<Value> arguments,
                                  Value append) {
  SmallVector<Value> ret(arguments);
  ret.push_back(append);
  return ret;
}

                           const SetVector<Operation*>& ops_to_add,
                           SmallVector<Operation*>& all_descendants) {
  if (!op) {
    return false;
  }

  SmallVector<Operation*> current_layer_descendants;
  SmallVector<Operation*> next_layer_descendants;
  int current_depth = 0;
  current_layer_descendants.push_back(op);
  // BFS downstream ops for current user.

def Size1InputRange : NativeCodeCall<
  "SmallVector<Value, 1>{$0}">;

def Size2InputRange : NativeCodeCall<
  "SmallVector<Value, 2>{$0, $1}">;

def Size3InputRange : NativeCodeCall<
  "SmallVector<Value, 3>{$0, $1, $2}">;

def EmptyCustomOptions : NativeCodeCall<
  "TFL::ConstBytesAttr::get($_builder.getContext(), \"\")">;