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();

    }
    TF_DeleteStatus(status);
  }

  Py_RETURN_TRUE;
}

std::vector<std::string> RetrieveCollectedErrors() {
  mlir::TFL::ErrorCollector* collector =
      mlir::TFL::ErrorCollector::GetErrorCollector();
  std::vector<std::string> collected_errors;
  for (const auto& error_data : collector->CollectedErrors()) {
    collected_errors.push_back(error_data.SerializeAsString());
  }
  collector->Clear();