Never filter-out compile errors in clang-tidy, display them as errors.

[alexfh]

Summary

No filters should affect the display of errors. Fixed a few tests,
which had compile errors.

We need to think what we should do with mapped errors (-Werror).

[klimek]

\o/

I think it's fine to count mapped errors as errors, as I'd expect clang-tidy to be a tool that generally is run after compilation works.

clang-tidy/ClangTidy.cpp

ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
   Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context, Options)));
   *Errors = Context.getErrors();
   return Context.getStats();
 }
 
 void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix) {
   ErrorReporter Reporter(Fix);
   for (const ClangTidyError &Error : Errors) {
-    Reporter.reportDiagnostic(Error.Message, DiagnosticsEngine::Warning,
-                              &Error.Fix);
+    Reporter.reportDiagnostic(
+        Error.Message, static_cast<DiagnosticsEngine::Level>(Error.DiagLevel),
     for (const ClangTidyMessage &Note : Error.Notes)
       Reporter.reportDiagnostic(Note, DiagnosticsEngine::Note);
   }
   Reporter.Finish();
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/ClangTidyDiagnosticConsumer.h

 /// \brief A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.
 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
 struct ClangTidyError {
-  ClangTidyError(StringRef CheckName);
+  enum Level {
+    Warning = DiagnosticsEngine::Warning,
+    Error = DiagnosticsEngine::Error
+  };
+
+  ClangTidyError(StringRef CheckName, Level DiagLevel);
 
   std::string CheckName;
   ClangTidyMessage Message;
   tooling::Replacements Fix;
   SmallVector<ClangTidyMessage, 1> Notes;
+
+  Level DiagLevel;
 };
 
 /// \brief Filters checks by name.
 class ChecksFilter {
 public:
   // GlobList is a comma-separated list of globs (only '*' metacharacter is
   // supported) with optional '-' prefix to denote exclusion.
   ChecksFilter(StringRef GlobList);

clang-tidy/ClangTidyDiagnosticConsumer.cpp

ClangTidyMessage::ClangTidyMessage(StringRef Message,
                                    const SourceManager &Sources,
                                    SourceLocation Loc)
     : Message(Message) {
   assert(Loc.isValid() && Loc.isFileID());
   FilePath = Sources.getFilename(Loc);
   FileOffset = Sources.getFileOffset(Loc);
 }
 
-ClangTidyError::ClangTidyError(StringRef CheckName) : CheckName(CheckName) {}
+ClangTidyError::ClangTidyError(StringRef CheckName,
+                               ClangTidyError::Level DiagLevel)
+    : CheckName(CheckName), DiagLevel(DiagLevel) {}
 
 // Returns true if GlobList starts with the negative indicator ('-'), removes it
 // from the GlobList.
 static bool ConsumeNegativeIndicator(StringRef &GlobList) {
   if (GlobList.startswith("-")) {
     GlobList = GlobList.substr(1);
     return true;
   }
Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
       /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
-    if (!Context.getChecksFilter().isCheckEnabled(Error.CheckName)) {
+    if (!Context.getChecksFilter().isCheckEnabled(Error.CheckName) &&
+        Error.DiagLevel != ClangTidyError::Error) {
       ++Context.Stats.ErrorsIgnoredCheckFilter;
       Errors.pop_back();
     } else if (!LastErrorRelatesToUserCode) {
       ++Context.Stats.ErrorsIgnoredNonUserCode;
       Errors.pop_back();
     } else if (!LastErrorPassesLineFilter) {
       ++Context.Stats.ErrorsIgnoredLineFilter;
       Errors.pop_back();
if (DiagLevel == DiagnosticsEngine::Note) {
     finalizeLastError();
     StringRef WarningOption =
         Context.DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(
             Info.getID());
     std::string CheckName = !WarningOption.empty()
                                 ? ("clang-diagnostic-" + WarningOption).str()
                                 : Context.getCheckName(Info.getID()).str();
 
-    Errors.push_back(ClangTidyError(CheckName));
+    ClangTidyError::Level Level = ClangTidyError::Warning;
+    if (DiagLevel == DiagnosticsEngine::Error ||
+        DiagLevel == DiagnosticsEngine::Fatal) {
+      Level = ClangTidyError::Error;
+      LastErrorRelatesToUserCode = true;
+      LastErrorPassesLineFilter = true;
+    }
+    Errors.push_back(ClangTidyError(CheckName, Level));
   }
 
   // FIXME: Provide correct LangOptions for each file.
   LangOptions LangOpts;
   ClangTidyDiagnosticRenderer Converter(
       LangOpts, &Context.DiagEngine->getDiagnosticOptions(), Errors.back());
   SmallString<100> Message;
   Info.FormatDiagnostic(Message);

test/clang-tidy/deduplication.cpp

 // RUN: clang-tidy -checks='-*,google-explicit-constructor' %s -- | FileCheck %s
 
 template<typename T>
-class A { A(T); };
-// CHECK: :[[@LINE-1]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
+struct A { A(T); };
+// CHECK: :[[@LINE-1]]:12: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 // CHECK-NOT: warning:
 
 
 void f() {
-  A<int> a;
-  A<double> b;
+  A<int> a(0);
+  A<double> b(0);
 }

test/clang-tidy/diagnostic.cpp

-// RUN: clang-tidy %s.nonexistent.cpp -- | FileCheck -check-prefix=CHECK1 %s
+// RUN: clang-tidy -checks='-*' %s.nonexistent.cpp -- | FileCheck -check-prefix=CHECK1 %s
 // RUN: clang-tidy -checks='google-explicit-constructor' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK2 %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor,clang-diagnostic-literal-conversion' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK3 %s
 // RUN: clang-tidy -checks='-*,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE | FileCheck -check-prefix=CHECK4 %s
 
 // CHECK1-NOT: warning
 // CHECK2-NOT: warning
 // CHECK3-NOT: warning
 
-// CHECK1: warning: error reading '{{.*}}.nonexistent.cpp'
-// CHECK2: warning: unknown argument: '-fan-unknown-option'
+// CHECK1: error: error reading '{{.*}}.nonexistent.cpp'
+// CHECK2: error: unknown argument: '-fan-unknown-option'
 
 // CHECK2: :[[@LINE+2]]:9: warning: implicit conversion from 'double' to 'int' changes value
 // CHECK3: :[[@LINE+1]]:9: warning: implicit conversion from 'double' to 'int' changes value
 int a = 1.5;
 
 // CHECK2: :[[@LINE+2]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 // CHECK3: :[[@LINE+1]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 class A { A(int) {} };
 
 // CHECK2-NOT: warning:
 // CHECK3-NOT: warning:
 
 #define MACRO_FROM_COMMAND_LINE
 // CHECK4: :[[@LINE-1]]:9: warning: 'MACRO_FROM_COMMAND_LINE' macro redefined

test/clang-tidy/redundant-smartptr-get.cpp

 // RUN: $(dirname %s)/check_clang_tidy_output.sh %s misc-redundant-smartptr-get
 // REQUIRES: shell
 
 // CHECK-NOT: warning
 
 namespace std {
 
 template <typename T>
-class unique_ptr {
+struct unique_ptr {
   T& operator*() const;
   T* operator->() const;
   T* get() const;
 };
 
 template <typename T>
-class shared_ptr {
+struct shared_ptr {
   T& operator*() const;
   T* operator->() const;
   T* get() const;
 };
 
 }  // namespace std
+#define NULL __null
 
 struct int_ptr {
   int* get();
   int* operator->();
   int& operator*();
 };
 
 struct Bar {