ConversionTarget target =
      GetDefaultLegalConversionTargets(context_, /*legalize_chlo=*/false);
  EXPECT_TRUE(target.isLegal(const_int));
}

TEST_F(XlaLegalizeTargetsTest, AllowsCHLODialect) {
  auto const_int = builder_.create<chlo::ConstantOp>(
      builder_.getUnknownLoc(), builder_.getI32TensorAttr({42}));

  ConversionTarget target =
      GetDefaultLegalConversionTargets(context_, /*legalize_chlo=*/true);

namespace mhlo {

// Returns a ConversionTarget that includes default legalized MLIR dialects
// for conversion to XLA.
// If legalize_chlo is true, the resulting conversion target cannot have CHLO.
mlir::ConversionTarget GetDefaultLegalConversionTargets(
    MLIRContext& mlir_context, bool legalize_chlo);

}  // namespace mhlo
}  // namespace mlir

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"

namespace mlir {
namespace mhlo {

ConversionTarget GetDefaultLegalConversionTargets(MLIRContext& mlir_context,
                                                  bool legalize_chlo) {
  ConversionTarget target(mlir_context);

  if (legalize_chlo) {

    return false;
  }
  return true;
}

void VerifyTFXLALegalization::runOnOperation() {
  Operation* func_op = getOperation();
  ConversionTarget default_conversion_target =
      GetDefaultLegalConversionTargets(getContext(), legalize_chlo_);

  bool has_invalid_ops = false;
  func_op->walk([&](Operation* op) {
    if (!IsMhloAndStatic(op)) {
      has_invalid_ops = true;

      ->IncrementBy(1);
}

mlir::LogicalResult ApplyPatterns(Operation *op, RewritePatternSet &patterns,
                                  bool legalize_chlo) {
  ConversionTarget target =
      GetDefaultLegalConversionTargets(*op->getContext(), legalize_chlo);

  DenseSet<Operation *> unconverted_ops;
  ConversionConfig config;
  config.unlegalizedOps = &unconverted_ops;