.getValues<APInt>()[perm.getSExtValue()]
                                  .getSExtValue()]);
    }
  }

  return mlir::DenseElementsAttr::get(
      RankedTensorType::get(
          {static_cast<int>(new_permutation.size())},
          mlir::IntegerType::get(permutation1.getContext(), 32)),
      llvm::ArrayRef(new_permutation));
}

                                          Location loc) {
  auto dims_type = mlir::dyn_cast<RankedTensorType>(dims.getType());
  if (!dims_type) return success();
  if (dims_type.getRank() > 1)
    return emitError(loc, "dimensions can only be 0D or 1D tensor");

  auto input_type = mlir::dyn_cast<RankedTensorType>(input.getType());
  if (!input_type) return success();
  int64_t rank = input_type.getRank();

  auto range = dense_attr.getValues<int64_t>();
  std::transform(range.begin(), range.end(), ret.begin(),
                 [](int64_t attr) { return static_cast<int32_t>(attr); });
  return DenseIntElementsAttr::get(
      RankedTensorType::get(ret.size(), builder.getIntegerType(32)), ret);
}

bool DenseI64AttrToI32Vector(const DenseIntElementsAttr& dense_attr,
                             std::vector<int32_t>* out_vec) {

        // Asset filenames are relative to the SavedModel directory.
        const std::string filename = tsl::io::JoinPath(
            saved_model_dir_, absl::string_view(asset.getFilename()));

        RankedTensorType type = RankedTensorType::get(
            {}, TF::StringType::get(builder.getContext()));
        auto const_op = builder.create<TF::ConstOp>(
            builder.getUnknownLoc(),

    Value scalar = op_builder->create<mhlo::ConstantOp>(
        const_op->getLoc(),
        DenseElementsAttr::get(
            RankedTensorType::get(/*shape=*/{}, element_type),
            splat_elements_attr.getSplatValue<Attribute>()));
    auto broadcast_dims = DenseIntElementsAttr::get(
        RankedTensorType::get(/*shape=*/{0}, op_builder->getI64Type()),
        llvm::SmallVector<int64_t>{});
    mhlo::BroadcastInDimOp broadcast_in_dim_op =

  if (auto ranked_type = mlir::dyn_cast<RankedTensorType>(type)) {
    ArrayRef<int64_t> shape = ranked_type.getShape();
    assert(permutation.size() == shape.size());

    SmallVector<int64_t, 4> new_shape(permutation.size());
    for (size_t i = 0; i < permutation.size(); ++i)
      new_shape[i] = shape[permutation[i]];

    return RankedTensorType::get(new_shape, ranked_type.getElementType());
  }

// Returns int, float or complex DenseElementsAttr with scalar shape with the
// given element type and the integer value.
template <typename T>
DenseElementsAttr GetScalarOfType(Type ty, T raw_value) {
  RankedTensorType scalar_ty = RankedTensorType::get({}, ty);
  if (auto float_ty = mlir::dyn_cast<FloatType>(ty)) {
    FloatAttr attr = FloatAttr::get(float_ty, raw_value);
    return DenseElementsAttr::get(scalar_ty, attr);

LogicalResult BatchMatMulOp::verify() {
  BatchMatMulOp op = *this;
  // batch size in lhs and rhs must be broadcastable
  RankedTensorType x_ty = op.getX().getType().dyn_cast<RankedTensorType>();
  RankedTensorType y_ty = op.getY().getType().dyn_cast<RankedTensorType>();

  if (!x_ty || !y_ty) return success();
  ArrayRef<int64_t> x_shape = x_ty.getShape();
  ArrayRef<int64_t> y_shape = y_ty.getShape();

}

Type ExpressedToQuantizedConverter::convert(
    quant::QuantizedType elemental_type) const {
  assert(expressed_type && "convert() on unsupported conversion");
  if (auto tensor_type = dyn_cast<RankedTensorType>(input_type))
    return RankedTensorType::get(tensor_type.getShape(), elemental_type);
  if (auto tensor_type = dyn_cast<UnrankedTensorType>(input_type))
    return UnrankedTensorType::get(elemental_type);

    auto broadcast_arg_type = mlir::dyn_cast_or_null<RankedTensorType>(
        broadcast.getInput().getType());
    if (!broadcast_arg_type || !broadcast_arg_type.hasStaticShape()) continue;

    // Check that the other argument has fully defined shape.
    auto argument_type = mlir::dyn_cast_or_null<RankedTensorType>(
        op->getOpOperand(1 - i).get().getType());