Store Errors inside ClangTidyContext instead of just pointer to an external array. This simplifies usage of ClangTidyContext a bit and seems to be more consistent.

[klimek]

LG. I think those changes have very small benefits (and I could argue both directions for each of them). I like what you propose slightly better, though.

clang-tidy/ClangTidy.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H
 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
+#include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 namespace tooling {
 class CompilationDatabase;
 }
 

 /// \brief Fills the list of check names that are enabled when the provided
 /// filters are applied.
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
 ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
                             const tooling::CompilationDatabase &Compilations,
                             ArrayRef<std::string> Ranges,
-                            SmallVectorImpl<ClangTidyError> *Errors);
+                            std::vector<ClangTidyError> *Errors);
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied.
-void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix);
+void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H

clang-tidy/ClangTidy.cpp

 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <algorithm>
 #include <utility>
-#include <vector>
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 namespace clang {
 namespace tidy {

 }
 
 void ClangTidyCheck::setName(StringRef Name) {
   assert(CheckName.empty());
   CheckName = Name.str();
 }
 
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
-  SmallVector<ClangTidyError, 8> Errors;
-  clang::tidy::ClangTidyContext Context(&Errors, Options);
+  clang::tidy::ClangTidyContext Context(Options);
   ClangTidyASTConsumerFactory Factory(Context, Options);
   return Factory.getCheckNames();
 }
 
 ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
                             const tooling::CompilationDatabase &Compilations,
                             ArrayRef<std::string> Ranges,
-                            SmallVectorImpl<ClangTidyError> *Errors) {
+                            std::vector<ClangTidyError> *Errors) {
   // FIXME: Ranges are currently full files. Support selecting specific
   // (line-)ranges.
   ClangTool Tool(Compilations, Ranges);
-  clang::tidy::ClangTidyContext Context(Errors, Options);
+  clang::tidy::ClangTidyContext Context(Options);
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyASTConsumerFactory *ConsumerFactory)
         : ConsumerFactory(ConsumerFactory) {}
private:
     private:
       ClangTidyASTConsumerFactory *Factory;
     };
 
     ClangTidyASTConsumerFactory *ConsumerFactory;
   };
 
   Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context, Options)));
+  *Errors = Context.getErrors();
   return Context.getStats();
 }
 
-void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix) {
+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);
     for (const ClangTidyMessage &Note : Error.Notes)
       Reporter.reportDiagnostic(Note, DiagnosticsEngine::Note);
   }
   Reporter.Finish();
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/ClangTidyDiagnosticConsumer.h

 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
 /// \endcode
 class ClangTidyContext {
 public:
-  ClangTidyContext(SmallVectorImpl<ClangTidyError> *Errors,
-                   const ClangTidyOptions &Options);
+  ClangTidyContext(const ClangTidyOptions &Options);
 
   /// \brief Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
   /// tablegen'd diagnostic IDs.
   /// FIXME: Figure out a way to manage ID spaces.
   DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
                          StringRef Message,
public:
 
   /// \brief Returns the name of the clang-tidy check which produced this
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
   ChecksFilter &getChecksFilter() { return Filter; }
   const ClangTidyOptions &getOptions() const { return Options; }
   const ClangTidyStats &getStats() const { return Stats; }
+  const std::vector<ClangTidyError> &getErrors() const { return Errors; }
 
 private:
   friend class ClangTidyDiagnosticConsumer; // Calls storeError().
 
   /// \brief Store a \c ClangTidyError.
   void storeError(const ClangTidyError &Error);
 
-  SmallVectorImpl<ClangTidyError> *Errors;
+  std::vector<ClangTidyError> Errors;
   DiagnosticsEngine *DiagEngine;
   ClangTidyOptions Options;
   ChecksFilter Filter;
   ClangTidyStats Stats;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 };
 

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 ChecksFilter::ChecksFilter(const ClangTidyOptions &Options)
     : EnableChecks(Options.EnableChecksRegex),
       DisableChecks(Options.DisableChecksRegex) {}
 
 bool ChecksFilter::isCheckEnabled(StringRef Name) {
   return EnableChecks.match(Name) && !DisableChecks.match(Name);
 }
 
-ClangTidyContext::ClangTidyContext(SmallVectorImpl<ClangTidyError> *Errors,
-                                   const ClangTidyOptions &Options)
-    : Errors(Errors), DiagEngine(nullptr), Options(Options), Filter(Options) {}
+ClangTidyContext::ClangTidyContext(const ClangTidyOptions &Options)
+    : DiagEngine(nullptr), Options(Options), Filter(Options) {}
 
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, SourceLocation Loc, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
   assert(Loc.isValid());
   bool Invalid;
   const char *CharacterData =
       DiagEngine->getSourceManager().getCharacterData(Loc, &Invalid);

 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
 /// \brief Store a \c ClangTidyError.
 void ClangTidyContext::storeError(const ClangTidyError &Error) {
-  Errors->push_back(Error);
+  Errors.push_back(Error);
 }
 
 StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
   llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";

 }
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (DiagLevel == DiagnosticsEngine::Note) {
     assert(!Errors.empty() &&
            "A diagnostic note can only be appended to a message.");
   } else {
+    // FIXME: Pass all errors here regardless of filters and non-user code.
     finalizeLastError();
     StringRef WarningOption =
         Context.DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(
             Info.getID());
     std::string CheckName = !WarningOption.empty()
                                 ? ("clang-diagnostic-" + WarningOption).str()
                                 : Context.getCheckName(Info.getID()).str();
 

clang-tidy/tool/ClangTidyMain.cpp

int main(int argc, const char **argv) {
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";
     for (auto CheckName : clang::tidy::getCheckNames(Options))
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
-  SmallVector<clang::tidy::ClangTidyError, 16> Errors;
+  std::vector<clang::tidy::ClangTidyError> Errors;
   clang::tidy::ClangTidyStats Stats =
       clang::tidy::runClangTidy(Options, OptionsParser.getCompilations(),
                                 OptionsParser.getSourcePathList(), &Errors);
   clang::tidy::handleErrors(Errors, Fix);
 
   printStats(Stats);
   return 0;
 }

unittests/clang-tidy/ClangTidyDiagnosticConsumerTest.cpp

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);
+  std::vector<ClangTidyError> 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

private:
   }
 
   ClangTidyCheck &Check;
   ClangTidyContext *Context;
 };
 
 template <typename T>
 std::string runCheckOnCode(StringRef Code,
-                           SmallVectorImpl<ClangTidyError> &Errors) {
+                           std::vector<ClangTidyError> *Errors = nullptr) {
   T Check;
-  ClangTidyContext Context(&Errors, ClangTidyOptions());
+  ClangTidyOptions Options;
+  ClangTidyContext Context(Options);
   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 (const ClangTidyError &Error : Errors)
+  for (const ClangTidyError &Error : Context.getErrors())
     Fixes.insert(Error.Fix.begin(), Error.Fix.end());
+  if (Errors)
+    *Errors = Context.getErrors();
   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