Add ClangTidyOptions to encapsulate all clang-tidy options.

[djasper]

Looks good.

[alexfh]

Actually adding ClangTidyOptions.h.

clang-tidy/ClangTidy.h

 //===--- ClangTidy.h - clang-tidy -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_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"
 
 namespace clang {
 
 class CompilerInstance;
private:
   SmallVector<ClangTidyCheck *, 8> Checks;
   ClangTidyContext &Context;
   ast_matchers::MatchFinder Finder;
   std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
 };
 
 /// \brief Fills the list of check names that are enabled when the provided
 /// filters are applied.
-std::vector<std::string> getCheckNames(StringRef EnableChecksRegex,
-                                       StringRef DisableChecksRegex);
+std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
-void runClangTidy(StringRef EnableChecksRegex, StringRef DisableChecksRegex,
+void runClangTidy(const ClangTidyOptions &Options,
                   const tooling::CompilationDatabase &Compilations,
                   ArrayRef<std::string> Ranges,
                   SmallVectorImpl<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);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H

clang-tidy/ClangTidy.cpp

void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   check(Result);
 }
 
 void ClangTidyCheck::setName(StringRef Name) {
   assert(CheckName.empty());
   CheckName = Name.str();
 }
 
-std::vector<std::string> getCheckNames(StringRef EnableChecksRegex,
-                                       StringRef DisableChecksRegex) {
+std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
   SmallVector<ClangTidyError, 8> Errors;
-  clang::tidy::ClangTidyContext Context(&Errors, EnableChecksRegex,
-                                        DisableChecksRegex);
+  clang::tidy::ClangTidyContext Context(&Errors, Options);
   ClangTidyASTConsumerFactory Factory(Context);
   return Factory.getCheckNames();
 }
 
-void runClangTidy(StringRef EnableChecksRegex, StringRef DisableChecksRegex,
+void runClangTidy(const ClangTidyOptions &Options,
                   const tooling::CompilationDatabase &Compilations,
                   ArrayRef<std::string> Ranges,
                   SmallVectorImpl<ClangTidyError> *Errors) {
   // FIXME: Ranges are currently full files. Support selecting specific
   // (line-)ranges.
   ClangTool Tool(Compilations, Ranges);
-  clang::tidy::ClangTidyContext Context(Errors, EnableChecksRegex,
-                                        DisableChecksRegex);
+  clang::tidy::ClangTidyContext Context(Errors, Options);
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyASTConsumerFactory *ConsumerFactory)
         : ConsumerFactory(ConsumerFactory) {}

clang-tidy/ClangTidyDiagnosticConsumer.h

 class MatchFinder;
 }
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
+struct ClangTidyOptions;
+
 /// \brief A message from a clang-tidy check.
 ///
 /// Note that this is independent of a \c SourceManager.
 struct ClangTidyMessage {
   ClangTidyMessage(StringRef Message = "");
   ClangTidyMessage(StringRef Message, const SourceManager &Sources,
                    SourceLocation Loc);
   std::string Message;
struct ClangTidyError {
   ClangTidyMessage Message;
   tooling::Replacements Fix;
   SmallVector<ClangTidyMessage, 1> Notes;
 };
 
 /// \brief Filters checks by name.
 class ChecksFilter {
 public:
-  ChecksFilter(StringRef EnableChecksRegex, StringRef DisableChecksRegex);
+  ChecksFilter(const ClangTidyOptions& Options);
   bool isCheckEnabled(StringRef Name);
 
 private:
   llvm::Regex EnableChecks;
   llvm::Regex DisableChecks;
 };
 
 /// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticEngine
 /// provided by this context.
 ///
 /// 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,
-                   StringRef EnableChecksRegex, StringRef DisableChecksRegex);
+                   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,

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 ///  This tool uses the Clang Tooling infrastructure, see
 ///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 ///  for details on setting it up with LLVM source tree.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyDiagnosticConsumer.h"
 
+#include "ClangTidyOptions.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "llvm/ADT/SmallString.h"
 
 #include <set>
 #include <tuple>
 
 namespace clang {
 namespace tidy {
ClangTidyMessage::ClangTidyMessage(StringRef Message,
   assert(Loc.isValid() && Loc.isFileID());
   FilePath = Sources.getFilename(Loc);
   FileOffset = Sources.getFileOffset(Loc);
 }
 
 ClangTidyError::ClangTidyError(StringRef CheckName)
     : CheckName(CheckName) {}
 
-ChecksFilter::ChecksFilter(StringRef EnableChecksRegex,
-                           StringRef DisableChecksRegex)
-    : EnableChecks(EnableChecksRegex), DisableChecks(DisableChecksRegex) {}
+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,
-                                   StringRef EnableChecksRegex,
-                                   StringRef DisableChecksRegex)
-    : Errors(Errors), DiagEngine(nullptr),
-      Filter(EnableChecksRegex, DisableChecksRegex) {}
+                                   const ClangTidyOptions &Options)
+    : Errors(Errors), DiagEngine(nullptr), 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);

clang-tidy/ClangTidyOptions.h

+//===--- ClangTidyOptions.h - clang-tidy ------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H
+
+namespace clang {
+namespace tidy {
+
+/// \brief Contains options for clang-tidy.
+struct ClangTidyOptions {
+  ClangTidyOptions() : EnableChecksRegex(".*") {}
+  std::string EnableChecksRegex;
+  std::string DisableChecksRegex;
+};
+
+} // end namespace tidy
+} // end namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H

clang-tidy/tool/ClangTidyMain.cpp

 
 static cl::opt<bool> ListChecks("list-checks",
                                 cl::desc("List all enabled checks and exit."),
                                 cl::init(false), cl::cat(ClangTidyCategory));
 
 int main(int argc, const char **argv) {
   CommonOptionsParser OptionsParser(argc, argv, ClangTidyCategory);
 
+  clang::tidy::ClangTidyOptions Options;
+  Options.EnableChecksRegex = Checks;
+  Options.DisableChecksRegex = DisableChecks;
+
   // FIXME: Allow using --list-checks without positional arguments.
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";
-    for (auto CheckName : clang::tidy::getCheckNames(Checks, DisableChecks))
+    for (auto CheckName : clang::tidy::getCheckNames(Options))
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
   SmallVector<clang::tidy::ClangTidyError, 16> Errors;
-  clang::tidy::runClangTidy(Checks, DisableChecks,
-                            OptionsParser.getCompilations(),
+  clang::tidy::runClangTidy(Options, OptionsParser.getCompilations(),
                             OptionsParser.getSourcePathList(), &Errors);
   clang::tidy::handleErrors(Errors, Fix);
 
   return 0;
 }
 
 namespace clang {
 namespace tidy {

unittests/clang-tidy/ClangTidyTest.h

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