auto callsite_loc3 = mlir::CallSiteLoc::get(loc_filtered2, loc3);

  // Test with filter on.
  StatusScopedDiagnosticHandler ssdh_filter(&context, false, true);
  emitError(callsite_loc) << "Error 1";
  emitError(callsite_loc2) << "Error 2";
  emitError(callsite_loc3) << "Error 3";
  Status s_filtered = ssdh_filter.ConsumeStatus();
  // Check for the files that should not be filtered.

    if (!nested_module) {
      op->emitError() << "could not parse attached MLIR module";
      return;
    }
    func::FuncOp main =
        dyn_cast<func::FuncOp>(nested_module->lookupSymbol("main"));
    if (!main) {
      op->emitError() << "MLIR Opaque Op expects a main() entry point\n";
      return;
    }
    if (main.getNumArguments() != op->getNumOperands()) {

    if (!backendConfig)
      return op->emitError(
          "custom_call has no 'composite.backend_config' attribute or the "
          "attribute is not a dictionary");

    auto name = mlir::dyn_cast<StringAttr>(backendConfig.get("name"));
    if (!name)
      return op->emitError(
          "backend_config has no 'name' key or the name value is not a string");

    auto attrs =

  absl::flat_hash_set<Node*> control_ret_nodes;
  Status status = tensorflow::tf2xla::v2::ConvertMlirToGraph(
      module_in, confs, &graph, &flib_def, &control_ret_nodes);
  if (!status.ok()) {
    mlir::emitError(mlir::UnknownLoc::get(&ctx)) << status.message();
    return signalPassFailure();
  }

  // Run each of the passes that were selected.
  GraphConstructorOptions opts;
  opts.allow_internal_ops = true;

    absl::StatusOr<SmallVector<SmallVector<int64_t>>> parsed_shapes;
    if (!input_arg_shapes_.empty()) {
      parsed_shapes = ParseArgumentShapes(input_arg_shapes_);
      if (!parsed_shapes.ok()) {
        getOperation().emitError() << parsed_shapes.status().message();
        return signalPassFailure();
      }
      input_shapes_vec = SmallVector<ArrayRef<int64_t>>{parsed_shapes->begin(),

          llvm::raw_string_ostream os{error_message};
          os << "The argument with type ";
          arg.getType().print(os);
          os << " should have one user, which should be tfr.cast.";
          func->emitError(error_message);
          return;
        }
      }
    }

    builder.setInsertionPoint(terminator);
    // Replace tfr.cast(tensor<quant_type>) -> output
    // with tfr.cast(tensor<storage_type>) -> output

  // Apply patterns to reachable functions.
  for (Operation* op : reachable_functions) {
    assert(isa<func::FuncOp>(op));
    if (failed(applyPatternsAndFoldGreedily(op, patterns))) {
      return op->emitError() << kBadDecompositionMessage;
    }
  }

  // Apply patterns to device cluster ops.
  // Note: This module search for cluster ops is a bit wasteful as we could have

                            MLIRContext* context, ArrayRef<StringAttr> attrs) {
    return Base::getChecked(emitError, context, attrs);
  }

  static Derived get(MLIRContext* context) { return get({}, context); }

  // TODO(fengliuai): fix the implementation
  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,

          absl::StrCat("Node `", op->getName().getStringRef().str(), "` ",
                       "is a launch op which should have been removed by "
                       "outside compilation");

      op->emitError() << launch_error;
      LOG(ERROR) << launch_error;
      return WalkResult::interrupt();
    }

    if (HasXlaOutsideCompilationMarker(*op)) {
      std::string outside_compilation_error = absl::StrCat(

  if (!(tensor_type && tensor_type.hasRank())) {
    return op->emitError()
           << "cannot convert op with unranked or non-tensor input type "
           << tensor_type << ".";
  }

  int rank = tensor_type.getRank();
  if (rank <= partition_dim) {
    return op->emitError() << "cannot partition " << first_operand_type
                           << " (rank = " << rank << ") along dimension "