#include "tensorflow/compiler/mlir/lite/metrics/error_collector.h"

namespace mlir {
namespace TFL {

ErrorCollector* ErrorCollector::error_collector_instance_ = nullptr;

ErrorCollector* ErrorCollector::GetErrorCollector() {
  if (error_collector_instance_ == nullptr) {
    error_collector_instance_ = new ErrorCollector();
  }
  return error_collector_instance_;
}

}  // namespace TFL

    collected_errors_.insert(error);
  }

  // Clear the set of collected errors.
  void Clear() { collected_errors_.clear(); }

  // Returns the global instance of ErrorCollector.
  static ErrorCollector* GetErrorCollector();

 private:
  ErrorCollector() {}

  ConverterErrorDataSet collected_errors_;

  static ErrorCollector* error_collector_instance_;
};

}  // namespace TFL
}  // namespace mlir

  pm.addInstrumentation(
      std::make_unique<ErrorCollectorInstrumentation>(&context));
  EXPECT_EQ(succeeded(pm.run(module.value().get())), true);

  auto collected_errors =
      ErrorCollector::GetErrorCollector()->CollectedErrors();
  EXPECT_EQ(collected_errors.size(), 0);
}

TEST(ErrorCollectorTest, TessFailurePass) {
  using tflite::metrics::ConverterErrorData;
  MLIRContext context;

                if (methodName == null) {
                    continue;
                }

                if (methodName.equals(MODEL)) {
                    source.getErrorCollector().addError(
                            new SyntaxException(NON_LITERAL_CLOSURE_TO_TOP_LEVEL_MODEL_MESSAGE, statement.getLineNumber(), statement.getColumnNumber()),
                            source
                    );

        }
        seenPluginManagementBlock = true;
        return statement;
    }

    private void addSyntaxError(String errorMessage, SourceUnit sourceUnit, Statement statement) {
        sourceUnit.getErrorCollector().addError(
            new SyntaxException(errorMessage, statement.getLineNumber(), statement.getColumnNumber()),
            sourceUnit
        );
    }

    @Nullable

// appended to the error message.
const int kMaxAcceptedNoteSize = 1024;
}  // namespace

ErrorCollectorInstrumentation::ErrorCollectorInstrumentation(
    MLIRContext *context)
    : error_collector_(ErrorCollector::GetErrorCollector()) {
  handler_ = std::make_unique<ScopedDiagnosticHandler>(
      context, [this](Diagnostic &diag) {
        if (diag.getSeverity() == DiagnosticSeverity::Error) {
          Location loc = diag.getLocation();

    }

    protected void restrict(ASTNode astNode) {
        restrict(astNode, message);
    }

    protected void restrict(ASTNode astNode, String message) {
        sourceUnit.getErrorCollector().addError(
                new SyntaxException(message, astNode.getLineNumber(), astNode.getColumnNumber()),
                sourceUnit
        );
    }

    @Override

                            Optional<ApiCompilerResult> partialResult = e.getCompilerPartialResult();
                            partialResult.ifPresent(result -> copyJavaCompilerResult(result));
                            cu.getErrorCollector().addFatalError(new SimpleMessage(e.getMessage(), cu));
                        }
                    }
                };
            }

    }

    private void wrapCompilationFailure(ScriptSource source, MultipleCompilationErrorsException e) {
        // Fix the source file name displayed in the error messages
        for (Object message : e.getErrorCollector().getErrors()) {
            if (message instanceof SyntaxErrorMessage) {
                try {
                    SyntaxErrorMessage syntaxErrorMessage = (SyntaxErrorMessage) message;

    }

    private void error(ASTNode call, String message) {
        SyntaxException syntaxException = new SyntaxException(message, call.getLineNumber(), call.getColumnNumber());
        sourceUnit.getErrorCollector().addError(syntaxException, sourceUnit);
    }

    public static String displayName(MethodCallExpression expression) {
        StringBuilder builder = new StringBuilder();