tflite::metrics::ConverterErrorData::ErrorCode error_code,
    const std::string& op_name, const Location& location) {
  using tflite::metrics::ConverterErrorData;
  ConverterErrorData error;
  if (!pass_name.empty()) {
    error.set_subcomponent(pass_name);
  }

  if (!error_message.empty()) {
    error.set_error_message(error_message);
  }

  if (!op_name.empty()) {
    error.mutable_operator_()->set_name(op_name);

class ErrorCollector {
  using ConverterErrorData = tflite::metrics::ConverterErrorData;
  using ConverterErrorDataSet =
      std::unordered_set<ConverterErrorData, ConverterErrorDataHash,
                         ConverterErrorDataComparison>;

 public:
  const ConverterErrorDataSet &CollectedErrors() { return collected_errors_; }

  void ReportError(const ConverterErrorData &error) {
    collected_errors_.insert(error);
  }

  }
};

// The comparison function for ConverterErrorData.
struct ConverterErrorDataComparison {
  std::size_t operator()(
      const tflite::metrics::ConverterErrorData& a,
      const tflite::metrics::ConverterErrorData& b) const noexcept {
    return ConverterErrorDataHash()(a) == ConverterErrorDataHash()(b);
  }
};

// Helper function to create a new ConverterErrorData.

              error_message += note_str.substr(0, kMaxAcceptedNoteSize);
              error_message += "...";
            }
          }

          ErrorCode error_code_enum = ConverterErrorData::UNKNOWN;
          bool has_valid_error_code =
              ConverterErrorData::ErrorCode_Parse(error_code, &error_code_enum);
          if (!op_name.empty() || has_valid_error_code) {
            error_collector_->ReportError(NewConverterErrorData(

namespace mlir {
namespace TFL {

// Collects errors when running the pass manager.
class ErrorCollectorInstrumentation : public PassInstrumentation {
  using ConverterErrorData = tflite::metrics::ConverterErrorData;
  using ErrorCode = ConverterErrorData::ErrorCode;

 public:
  explicit ErrorCollectorInstrumentation(MLIRContext *context);

 private:

        AttachErrorCode(
            nestedOp->emitError()
                << "Failed at " << nestedOp->getName().getStringRef().str()
                << " op",
            tflite::metrics::ConverterErrorData::ERROR_NEEDS_FLEX_OPS);
      }
    });
    signalPassFailure();
  };
};

absl::StatusOr<OwningOpRef<mlir::ModuleOp>> LoadModule(
    MLIRContext* context, const std::string& file_name) {

            "instead. See https://www.tensorflow.org/api_docs/python/tf/compat/"
            "v1/enable_control_flow_v2."),
        tflite::metrics::ConverterErrorData::ERROR_UNSUPPORTED_CONTROL_FLOW_V1);
    return mlir::failure();
  }
  return mlir::success();
}

mlir::LogicalResult GraphContainsStatefulPartitionedOp(mlir::ModuleOp module) {

            tflite::metrics::ConverterErrorData::ERROR_NEEDS_FLEX_OPS);
      } else {
        failed_custom_ops_[op_name].insert(op_desc);
        tfl::AttachErrorCode(
            inst->emitOpError("is neither a custom op nor a flex op"),
            tflite::metrics::ConverterErrorData::ERROR_NEEDS_CUSTOM_OPS);
      }
      return std::nullopt;
    }