[mlir] Add mlir translate flag to print errors only.

[gysit]

Summary

The revision adds a flag to mlir translate that suppresses
any non-error diagnostics. The flag is useful when importing
LLVM IR to LLVM dialect, which produces a lot of
warnings due to dropped metadata and debug intrinsics.

[Dinistro]

LGTM!

mlir/lib/Tools/mlir-translate/MlirTranslateMain.cpp

 #include "mlir/Tools/mlir-translate/Translation.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
-// Translation Parser
+// Diagnostic Filter
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// A scoped diagnostic handler that marks non-error diagnostics as handled. As
+/// a result, the main diagnostic handler does not print non-error diagnostics.
+class ErrorDiagnosticFilter : public ScopedDiagnosticHandler {
+public:
+  ErrorDiagnosticFilter(MLIRContext *ctx) : ScopedDiagnosticHandler(ctx) {
+    setHandler([](Diagnostic &diag) {
+      if (diag.getSeverity() != DiagnosticSeverity::Error)
+        return success();
+      return failure();
+    });
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Translate Entry Point
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::mlirTranslateMain(int argc, char **argv,
                                       llvm::StringRef toolName) {
 
   static llvm::cl::opt<std::string> inputFilename(
       llvm::cl::Positional, llvm::cl::desc("<input file>"),
       llvm::cl::init("-"));
static llvm::cl::opt<bool> splitInputFile(
       llvm::cl::init(false));
 
   static llvm::cl::opt<bool> verifyDiagnostics(
       "verify-diagnostics",
       llvm::cl::desc("Check that emitted diagnostics match "
                      "expected-* lines on the corresponding line"),
       llvm::cl::init(false));
 
+  static llvm::cl::opt<bool> errorDiagnosticsOnly(
+      "error-diagnostics-only",
+      llvm::cl::desc("Filter all non-error diagnostics "
+                     "(discouraged: testing only!)"),
+      llvm::cl::init(false));
+
   llvm::InitLLVM y(argc, argv);
 
   // Add flags for all the registered translations.
   llvm::cl::list<const Translation *, bool, TranslationParser>
       translationsRequested("", llvm::cl::desc("Translations to perform"),
                             llvm::cl::Required);
   registerAsmPrinterCLOptions();
   registerMLIRContextCLOptions();
for (size_t i = 0, e = translationsRequested.size(); i < e; ++i) {
       MLIRContext context;
       context.allowUnregisteredDialects(allowUnregisteredDialects);
       context.printOpOnDiagnostic(!verifyDiagnostics);
       auto sourceMgr = std::make_shared<llvm::SourceMgr>();
       sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
 
       if (verifyDiagnostics) {
         // In the diagnostic verification flow, we ignore whether the
-        // translation failed (in most cases, it is expected to fail).
-        // Instead, we check if the diagnostics were produced as expected.
+        // translation failed (in most cases, it is expected to fail) and we do
+        // not filter non-error diagnostics even if `errorDiagnosticsOnly` is
+        // set. Instead, we check if the diagnostics were produced as expected.
         SourceMgrDiagnosticVerifierHandler sourceMgrHandler(*sourceMgr,
                                                             &context);
         (void)(*translationRequested)(sourceMgr, os, &context);
         result = sourceMgrHandler.verify();
+      } else if (errorDiagnosticsOnly) {
+        SourceMgrDiagnosticHandler sourceMgrHandler(*sourceMgr, &context);
+        ErrorDiagnosticFilter diagnosticFilter(&context);
+        result = (*translationRequested)(sourceMgr, *stream, &context);
       } else {
         SourceMgrDiagnosticHandler sourceMgrHandler(*sourceMgr, &context);
         result = (*translationRequested)(sourceMgr, *stream, &context);
       }
       if (failed(result))
         return result;
 
       if (i < e - 1) {

mlir/test/mlir-translate/import-error-only.ll

+; RUN: not mlir-translate %s -import-llvm -split-input-file -error-diagnostics-only 2>&1 | FileCheck %s --check-prefix=ERROR
+; RUN: not mlir-translate %s -import-llvm -split-input-file 2>&1 | FileCheck %s --check-prefix=ALL
+
+; ERROR-NOT: warning:
+; ALL:       warning:
+define void @warning(i64 %n, ptr %A) {
+entry:
+  br label %end, !llvm.loop !0
+end:
+  ret void
+}
+
+!0 = distinct !{!0, !1, !2}
+!1 = !{!"llvm.loop.disable_nonforced"}
+!2 = !{!"llvm.loop.typo"}
+
+; // -----
+
+; ERROR: error:
+; ALL:   error:
+define i32 @error(ptr %dst) {
+  indirectbr ptr %dst, [label %bb1, label %bb2]
+bb1:
+  ret i32 0
+bb2:
+  ret i32 1
+}