Output clang-tidy errors in a consistent order.

[alexfh]

Summary

Sort errors by path, file offset and message.

[djasper]

Looks good.

clang-tidy/ClangTidyDiagnosticConsumer.cpp

struct LessClangTidyError {
   }
 };
 
 // Flushes the internal diagnostics buffer to the ClangTidyContext.
 void ClangTidyDiagnosticConsumer::finish() {
   finalizeLastError();
   std::set<const ClangTidyError*, LessClangTidyError> UniqueErrors;
   for (const ClangTidyError &Error : Errors) {
-    if (Context.getChecksFilter().isCheckEnabled(Error.CheckName) &&
-        UniqueErrors.insert(&Error).second)
-      Context.storeError(Error);
+    if (Context.getChecksFilter().isCheckEnabled(Error.CheckName))
+      UniqueErrors.insert(&Error);
   }
+  for (const ClangTidyError *Error : UniqueErrors)
+    Context.storeError(*Error);
   Errors.clear();
 }
 
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 get_filename_component(CLANG_LINT_SOURCE_DIR
   ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-tidy REALPATH)
 include_directories(${CLANG_LINT_SOURCE_DIR})
 
 add_extra_unittest(ClangTidyTests
+  ClangTidyDiagnosticConsumerTest.cpp
   LLVMModuleTest.cpp
   GoogleModuleTest.cpp
   MiscModuleTest.cpp)
 
 target_link_libraries(ClangTidyTests
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangTidy
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTooling
   )

unittests/clang-tidy/ClangTidyDiagnosticConsumerTest.cpp

+#include "ClangTidy.h"
+#include "ClangTidyTest.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace tidy {
+namespace test {
+
+class TestCheck : public ClangTidyCheck {
+public:
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override {
+    Finder->addMatcher(ast_matchers::varDecl().bind("var"), this);
+  }
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
+    const VarDecl *Var = Result.Nodes.getNodeAs<VarDecl>("var");
+    // Add diagnostics in the wrong order.
+    diag(Var->getLocation(), "variable");
+    diag(Var->getTypeSpecStartLoc(), "type specifier");
+  }
+};
+
+TEST(ClangTidyDiagnosticConsumer, SortsErrors) {
+  SmallVector<ClangTidyError, 8> Errors;
+  runCheckOnCode<TestCheck>("int a;", Errors);
+  EXPECT_EQ(2ul, Errors.size());
+  // FIXME: Remove " []" once the check name is removed from the message text.
+  EXPECT_EQ("type specifier []", Errors[0].Message.Message);
+  EXPECT_EQ("variable []", Errors[1].Message.Message);
+}
+
+} // namespace test
+} // namespace tidy
+} // namespace clang

unittests/clang-tidy/ClangTidyTest.h

bool BeginSourceFileAction(CompilerInstance &Compiler,
     Check.registerPPCallbacks(Compiler);
     return true;
   }
 
   ClangTidyCheck &Check;
   ClangTidyContext *Context;
 };
 
-template <typename T> std::string runCheckOnCode(StringRef Code) {
+template <typename T>
+std::string runCheckOnCode(StringRef Code,
+                           SmallVectorImpl<ClangTidyError> &Errors) {
   T Check;
-  SmallVector<ClangTidyError, 16> Errors;
   ClangTidyContext Context(&Errors, ".*", "");
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
   Check.setContext(&Context);
   std::vector<std::string> ArgCXX11(1, "-std=c++11");
 
   if (!tooling::runToolOnCodeWithArgs(new TestPPAction(Check, &Context), Code,
                                       ArgCXX11))
     return "";
   ast_matchers::MatchFinder Finder;
   Check.registerMatchers(&Finder);
   std::unique_ptr<tooling::FrontendActionFactory> Factory(
       tooling::newFrontendActionFactory(&Finder));
   if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, ArgCXX11))
     return "";
   DiagConsumer.finish();
   tooling::Replacements Fixes;
   for (SmallVector<ClangTidyError, 16>::const_iterator I = Errors.begin(),
                                                        E = Errors.end();
        I != E; ++I)
     Fixes.insert(I->Fix.begin(), I->Fix.end());
   return tooling::applyAllReplacements(Code, Fixes);
 }
 
+template <typename T> std::string runCheckOnCode(StringRef Code) {
+  SmallVector<ClangTidyError, 16> Errors;
+  return runCheckOnCode<T>(Code, Errors);
+}
+
 } // namespace test
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_TIDY_CLANG_TIDY_TEST_H