>,
  ];
}

//===----------------------------------------------------------------------===//
// TFL op interface for sparse operands.

def TFL_SparseOp : OpInterface<"SparseOpInterface"> {
  let description = [{
    Interface for ops that support sparse computation.
  }];

  let methods = [
    InterfaceMethod<
      [{Returns the indices of sparse operands.}],

  os.indent(4) << "new std::set<std::string>({\n";

  // Retrieve all the ops that have SparseOp trait.
  for (const auto *def : defs) {
    Operator op(def);
    if (!op.getTrait("SparseOpInterface::Trait")) {
      continue;
    }
    os.indent(6) << "\"" << op.getCppClassName() << "\",\n";
  }

  os.indent(4) << "});";
  os.indent(2) << "return *result;\n";
  os.indent(0) << "}\n";
}

  void runOnOperation() override;
};

void DenseToSparsePass::runOnOperation() {
  func::FuncOp func = getOperation();
  OpBuilder builder(func);

  func.walk([&](SparseOpInterface sparse_op) {
    const auto& sparse_operands = sparse_op.GetSparseOperands();
    std::vector<std::vector<int>> supported_block_size;
    for (int operand : sparse_operands) {
      auto* op = sparse_op.getOperation();

  let hasVerifier = 1;

  let extraClassDeclaration = [{
    // AffineQuantizedOpInterface:
    int GetChannelDimIndex() { return 0; }
    int GetQuantizationDimIndex() { return 0; }
    // SparseOpInterface:
    std::vector<int> GetSparseOperands() { return {1}; }
    std::vector<std::vector<int>> GetFloatBlockSize() { return {}; }
    std::vector<std::vector<int>> GetQuantizedBlockSize() { return {}; }