Allow per-file clang-tidy options.

[alexfh]

Summary

This patch makes it possible for clang-tidy clients to provide
different options for different translation units. The option, which doesn't
make sense to be file-dependent, was moved to a separate ClangTidyGlobalOptions
struct. Added parsing of ClangTidyOptions.

[alexfh]

Added a comment and an assertion, replaced a couple of |= with definitely short cirtuited versions.

[klimek]

clang-tidy/ClangTidy.cpp

208

Any reasons for not using a vector of unique_ptr's an moving that into the ASTConsumer?

216

Finder.get()?

269

Wait, this seems to have been incorrect before (| instead of logical ||), and I think we're missing parens.

clang-tidy/ClangTidyDiagnosticConsumer.h

170

Any reason not to store a std::string here? Seems fragile to store a StringRef.

clang-tidy/ClangTidyOptions.h

30–31

... for which we show warnings.

35

neither... nor...

38–39

I think the second sentence doesn't help. I'd delete it.

76–78

I'd vote for putting members at the end of the class.

[alexfh]

Addressed review comments.

clang-tidy/ClangTidy.cpp

208

Just didn't want to touch the createChecks method. But this isn't a serious reason. Fixed.

216

It's a matter of taste. I slightly prefer &*, and &* is used two more times in this file (lines 98, 99) and in other files in clang-tidy. If you have serious reasons to prefer .get() over &*, I can change all of the usages in a separate patch, but now I would like the code to be consistent in this regard.

269

Err, it's actually incorrect now (| instead of ||). And we're missing parens (to mute the compiler warning). Before this patch it was kind of correct (except that it wasn't short circuited).

Fixed.

clang-tidy/ClangTidyDiagnosticConsumer.h

170

You're right. Changed.

clang-tidy/ClangTidyOptions.h

30–31

Done.

35

Done.

38–39

I'd leave it, as it's describes a special case. Without special-casing the empty list, the list would be applied always, and the empty list would mean that no warnings will pass the filter.

76–78

Done.

[klimek]

lg

clang-tidy/ClangTidy.cpp

216

I'm probably in the "more explicit" camp here - &* will work on anything that's deref'able, .get() will only work on smart-pointer-compatible types. I like the fact that I am able to tell whether &* is just a no-op after a refactoring/replacement that hasn't been noticed (for example, after changing a reference to a pointer variable), or whether it's an intentional retrieval of the pointer.

I don't care too much, so feel free to leave it in.

clang-tidy/ClangTidyOptions.h

38–39

Interesting. My default interpretation of a filter is "for all filter, take out what it matches", which, if applied with an empty filter, doesn't change anything.
Perhaps:
If empty, no warnings will be filtered.
(or something like that)

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 <memory>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 namespace tooling {
 class CompilationDatabase;
 }
private:
   ClangTidyContext *Context;
   std::string CheckName;
 };
 
 class ClangTidyCheckFactories;
 
 class ClangTidyASTConsumerFactory {
 public:
-  ClangTidyASTConsumerFactory(ClangTidyContext &Context,
-                              const ClangTidyOptions &Options);
-  ~ClangTidyASTConsumerFactory();
+  ClangTidyASTConsumerFactory(ClangTidyContext &Context);
 
   /// \brief Returns an ASTConsumer that runs the specified clang-tidy checks.
   clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler,
                                         StringRef File);
 
   /// \brief Get the list of enabled checks.
-  std::vector<std::string> getCheckNames();
+  std::vector<std::string> getCheckNames(ChecksFilter &Filter);
 
 private:
   typedef std::vector<std::pair<std::string, bool> > CheckersList;
-  CheckersList getCheckersControlList();
+  CheckersList getCheckersControlList(ChecksFilter &Filter);
 
-  SmallVector<ClangTidyCheck *, 8> Checks;
   ClangTidyContext &Context;
-  ast_matchers::MatchFinder Finder;
   std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
-  ClangTidyOptions Options;
 };
 
 /// \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> InputFiles,
-                            std::vector<ClangTidyError> *Errors);
+///
+/// Takes ownership of the \c OptionsProvider.
+ClangTidyStats
+runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
 
 // 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(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

private:
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   Rewriter Rewrite;
   bool ApplyFixes;
   unsigned TotalFixes;
   unsigned AppliedFixes;
 };
 
+class ClangTidyASTConsumer : public MultiplexConsumer {
+public:
+  ClangTidyASTConsumer(const SmallVectorImpl<ASTConsumer *> &Consumers,
+                       std::unique_ptr<ast_matchers::MatchFinder> Finder,
+                       const SmallVectorImpl<ClangTidyCheck *> &Checks)
+      : MultiplexConsumer(Consumers), Finder(std::move(Finder)) {
+    for (ClangTidyCheck *Check : Checks)
+      this->Checks.emplace_back(Check);
+  }
+
+private:
+  std::unique_ptr<ast_matchers::MatchFinder> Finder;
+  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
+};
+
 } // namespace
 
 ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
-    ClangTidyContext &Context, const ClangTidyOptions &Options)
-    : Context(Context), CheckFactories(new ClangTidyCheckFactories),
-      Options(Options) {
+    ClangTidyContext &Context)
+    : Context(Context), CheckFactories(new ClangTidyCheckFactories) {
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                          E = ClangTidyModuleRegistry::end();
        I != E; ++I) {
     std::unique_ptr<ClangTidyModule> Module(I->instantiate());
     Module->addCheckFactories(*CheckFactories);
   }
-
-  CheckFactories->createChecks(Context.getChecksFilter(), Checks);
-
-  for (ClangTidyCheck *Check : Checks) {
-    Check->setContext(&Context);
-    Check->registerMatchers(&Finder);
-  }
 }
 
-ClangTidyASTConsumerFactory::~ClangTidyASTConsumerFactory() {
-  for (ClangTidyCheck *Check : Checks)
-    delete Check;
-}
 
 clang::ASTConsumer *ClangTidyASTConsumerFactory::CreateASTConsumer(
     clang::CompilerInstance &Compiler, StringRef File) {
   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
   // modify Compiler.
   Context.setSourceManager(&Compiler.getSourceManager());
-  for (ClangTidyCheck *Check : Checks)
+  Context.setCurrentFile(File);
+
+  SmallVector<ClangTidyCheck*, 8> Checks;
+  ChecksFilter &Filter = Context.getChecksFilter();
+  CheckFactories->createChecks(Filter, Checks);
+
+  std::unique_ptr<ast_matchers::MatchFinder> Finder(
+      new ast_matchers::MatchFinder);
+  for (ClangTidyCheck *Check : Checks) {
+    Check->setContext(&Context);
+    Check->registerMatchers(&*Finder);
     Check->registerPPCallbacks(Compiler);
+  }
 
   SmallVector<ASTConsumer *, 2> Consumers;
-  if (!CheckFactories->empty())
-    Consumers.push_back(Finder.newASTConsumer());
+  if (!Checks.empty())
+    Consumers.push_back(Finder->newASTConsumer());
 
   AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
   // FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
   // to true.
   AnalyzerOptions->Config["cfg-temporary-dtors"] =
-      Options.AnalyzeTemporaryDtors ? "true" : "false";
+      Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
 
-  AnalyzerOptions->CheckersControlList = getCheckersControlList();
+  AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
   if (!AnalyzerOptions->CheckersControlList.empty()) {
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
     AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
     AnalyzerOptions->AnalyzeNestedBlocks = true;
     AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
     ento::AnalysisASTConsumer *AnalysisConsumer = ento::CreateAnalysisConsumer(
         Compiler.getPreprocessor(), Compiler.getFrontendOpts().OutputFile,
         AnalyzerOptions, Compiler.getFrontendOpts().Plugins);
     AnalysisConsumer->AddDiagnosticConsumer(
         new AnalyzerDiagnosticConsumer(Context));
     Consumers.push_back(AnalysisConsumer);
   }
-  return new MultiplexConsumer(Consumers);
+  return new ClangTidyASTConsumer(Consumers, std::move(Finder), Checks);
 }
 
-std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
+std::vector<std::string>
+ClangTidyASTConsumerFactory::getCheckNames(ChecksFilter &Filter) {
   std::vector<std::string> CheckNames;
   for (const auto &CheckFactory : *CheckFactories) {
-    if (Context.getChecksFilter().isCheckEnabled(CheckFactory.first))
+    if (Filter.isCheckEnabled(CheckFactory.first))
       CheckNames.push_back(CheckFactory.first);
   }
 
-  for (const auto &AnalyzerCheck : getCheckersControlList())
+  for (const auto &AnalyzerCheck : getCheckersControlList(Filter))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 
   std::sort(CheckNames.begin(), CheckNames.end());
   return CheckNames;
 }
 
 ClangTidyASTConsumerFactory::CheckersList
-ClangTidyASTConsumerFactory::getCheckersControlList() {
+ClangTidyASTConsumerFactory::getCheckersControlList(ChecksFilter &Filter) {
   CheckersList List;
 
   bool AnalyzerChecksEnabled = false;
   for (StringRef CheckName : StaticAnalyzerChecks) {
     std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
-    AnalyzerChecksEnabled |=
-        Context.getChecksFilter().isCheckEnabled(Checker) &&
-        !CheckName.startswith("debug");
+    AnalyzerChecksEnabled =
+        AnalyzerChecksEnabled | !CheckName.startswith("debug") &&
+        Filter.isCheckEnabled(Checker);
   }
 
   if (AnalyzerChecksEnabled) {
     // Run our regex against all possible static analyzer checkers.  Note that
     // debug checkers print values / run programs to visualize the CFG and are
     // thus not applicable to clang-tidy in general.
     //
     // Always add all core checkers if any other static analyzer checks are
     // enabled. This is currently necessary, as other path sensitive checks
     // rely on the core checkers.
     for (StringRef CheckName : StaticAnalyzerChecks) {
       std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
 
       if (CheckName.startswith("core") ||
-          (!CheckName.startswith("debug") &&
-           Context.getChecksFilter().isCheckEnabled(Checker)))
+          (!CheckName.startswith("debug") && Filter.isCheckEnabled(Checker)))
         List.push_back(std::make_pair(CheckName, true));
     }
   }
   return List;
 }
 
 DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,
                                        DiagnosticIDs::Level Level) {
   return Context->diag(CheckName, Loc, Message, Level);
 }
 
 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   Context->setSourceManager(Result.SourceManager);
   check(Result);
 }
 
 void ClangTidyCheck::setName(StringRef Name) {
   assert(CheckName.empty());
   CheckName = Name.str();
 }
 
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
-  clang::tidy::ClangTidyContext Context(Options);
-  ClangTidyASTConsumerFactory Factory(Context, Options);
-  return Factory.getCheckNames();
+  clang::tidy::ClangTidyContext Context(
+      new DefaultOptionsProvider(ClangTidyGlobalOptions(), Options));
+  ClangTidyASTConsumerFactory Factory(Context);
+  return Factory.getCheckNames(Context.getChecksFilter());
 }
 
-ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
+ClangTidyStats runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
                             const tooling::CompilationDatabase &Compilations,
                             ArrayRef<std::string> InputFiles,
                             std::vector<ClangTidyError> *Errors) {
   ClangTool Tool(Compilations, InputFiles);
-  clang::tidy::ClangTidyContext Context(Options);
+  clang::tidy::ClangTidyContext Context(OptionsProvider);
   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)));
+  Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context)));
   *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,

clang-tidy/ClangTidyDiagnosticConsumer.h

struct ClangTidyError {
   ClangTidyMessage Message;
   tooling::Replacements Fix;
   SmallVector<ClangTidyMessage, 1> Notes;
 };
 
 /// \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.
+  /// \brief \p GlobList is a comma-separated list of globs (only '*'
+  /// metacharacter is supported) with optional '-' prefix to denote exclusion.
   ChecksFilter(StringRef GlobList);
-  // Returns true if the check with the specified Name should be enabled.
-  // The result is the last matching glob's Positive flag. If Name is not
-  // matched by any globs, the check is not enabled.
+
+  /// \brief Returns \c true if the check with the specified \p Name should be
+  /// enabled. The result is the last matching glob's Positive flag. If \p Name
+  /// is not matched by any globs, the check is not enabled.
   bool isCheckEnabled(StringRef Name) { return isCheckEnabled(Name, false); }
 
 private:
   bool isCheckEnabled(StringRef Name, bool Enabled);
 
   bool Positive;
   llvm::Regex Regex;
   std::unique_ptr<ChecksFilter> NextFilter;
 };
 
+/// \brief Contains displayed and ignored diagnostic counters for a ClangTidy
+/// run.
 struct ClangTidyStats {
   ClangTidyStats()
       : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
         ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
 
   unsigned ErrorsDisplayed;
   unsigned ErrorsIgnoredCheckFilter;
   unsigned ErrorsIgnoredNOLINT;

 /// 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(const ClangTidyOptions &Options);
+  /// \brief Initializes \c ClangTidyContext instance.
+  ///
+  /// Takes ownership of the \c OptionsProvider.
+  ClangTidyContext(ClangTidyOptionsProvider *OptionsProvider);
 
   /// \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,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
-  /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
-  /// correctly.
-  ///
-  /// This is called from the \c ClangTidyCheck base class.
-  void setDiagnosticsEngine(DiagnosticsEngine *Engine);
-
   /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
+  /// \brief Should be called when starting to process new translation unit.
+  void setCurrentFile(StringRef File);
+
   /// \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; }
+  /// \brief Returns check filter for the \c CurrentFile.
+  ChecksFilter &getChecksFilter();
+
+  /// \brief Returns global options.
+  const ClangTidyGlobalOptions &getGlobalOptions() const;
+
+  /// \brief Returns options for \c CurrentFile.
+  const ClangTidyOptions &getOptions() const;
+
+  /// \brief Returns \c ClangTidyStats containing issued and ignored diagnostic
+  /// counters.
   const ClangTidyStats &getStats() const { return Stats; }
+
+  /// \brief Returns all collected errors.
   const std::vector<ClangTidyError> &getErrors() const { return Errors; }
+
+  /// \brief Clears collected errors.
   void clearErrors() { Errors.clear(); }
 
 private:
-  friend class ClangTidyDiagnosticConsumer; // Calls storeError().
+  // Calls setDiagnosticsEngine() and storeError().
+  friend class ClangTidyDiagnosticConsumer;
 
-  /// \brief Store a \c ClangTidyError.
+  /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
+  /// correctly.
+  void setDiagnosticsEngine(DiagnosticsEngine *Engine);
+
+  /// \brief Store an \p Error.
   void storeError(const ClangTidyError &Error);
 
   std::vector<ClangTidyError> Errors;
   DiagnosticsEngine *DiagEngine;
-  ClangTidyOptions Options;
-  ChecksFilter Filter;
+  std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
+
+  StringRef CurrentFile;
+  std::unique_ptr<ChecksFilter> CheckFilter;
+
   ClangTidyStats Stats;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a
 /// \c SourceManager-independent \c ClangTidyError.
 //
 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
   ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx);
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
-  // Flushes the internal diagnostics buffer to the ClangTidyContext.
+  /// \brief Sets \c HeaderFilter to the value configured for this file.
+  void BeginSourceFile(const LangOptions &LangOpts,
+                       const Preprocessor *PP) override;
+
+  /// \brief Flushes the internal diagnostics buffer to the ClangTidyContext.
   void finish() override;
 
 private:
   void finalizeLastError();
+
+  /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
+  /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   ClangTidyContext &Context;
-  llvm::Regex HeaderFilter;
   std::unique_ptr<DiagnosticsEngine> Diags;
   SmallVector<ClangTidyError, 8> Errors;
+  std::unique_ptr<llvm::Regex> HeaderFilter;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_DIAGNOSTIC_CONSUMER_H

clang-tidy/ClangTidyDiagnosticConsumer.cpp

bool ChecksFilter::isCheckEnabled(StringRef Name, bool Enabled) {
   if (Regex.match(Name))
     Enabled = Positive;
 
   if (NextFilter)
     Enabled = NextFilter->isCheckEnabled(Name, Enabled);
   return Enabled;
 }
 
-ClangTidyContext::ClangTidyContext(const ClangTidyOptions &Options)
-    : DiagEngine(nullptr), Options(Options), Filter(Options.Checks) {}
+ClangTidyContext::ClangTidyContext(ClangTidyOptionsProvider *OptionsProvider)
+    : DiagEngine(nullptr), OptionsProvider(OptionsProvider) {
+  // Before the first translation unit we can get errors related to command-line
+  // parsing, use empty string for the file name in this case.
+  setCurrentFile("");
+}
 
 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::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
   DiagEngine = Engine;
 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
+void ClangTidyContext::setCurrentFile(StringRef File) {
+  CurrentFile = File;
+  CheckFilter.reset(new ChecksFilter(getOptions().Checks));
+}
+
+const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
+  return OptionsProvider->getGlobalOptions();
+}
+
+const ClangTidyOptions &ClangTidyContext::getOptions() const {
+  return OptionsProvider->getOptions(CurrentFile);
+}
+
+ChecksFilter &ClangTidyContext::getChecksFilter() {
+  assert(CheckFilter != nullptr);
+  return *CheckFilter;
+}
+
 /// \brief Store a \c ClangTidyError.
 void ClangTidyContext::storeError(const ClangTidyError &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 "";
 }
 
 ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
-    : Context(Ctx), HeaderFilter(Ctx.getOptions().HeaderFilterRegex),
-      LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false) {
+    : Context(Ctx), LastErrorRelatesToUserCode(false),
+      LastErrorPassesLineFilter(false) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
       /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
   if (Info.hasSourceManager())
     Sources = &Info.getSourceManager();
   Converter.emitDiagnostic(Info.getLocation(), DiagLevel, Message,
                            Info.getRanges(), Info.getFixItHints(), Sources);
 
   checkFilters(Info.getLocation());
 }
 
+void ClangTidyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
+                                                  const Preprocessor *PP) {
+  // Before the first translation unit we don't need HeaderFilter, as we
+  // shouldn't get valid source locations in diagnostics.
+  HeaderFilter.reset(new llvm::Regex(Context.getOptions().HeaderFilterRegex));
+}
+
 bool ClangTidyDiagnosticConsumer::passesLineFilter(StringRef FileName,
                                                    unsigned LineNumber) const {
-  if (Context.getOptions().LineFilter.empty())
+  if (Context.getGlobalOptions().LineFilter.empty())
     return true;
-  for (const FileFilter& Filter : Context.getOptions().LineFilter) {
+  for (const FileFilter& Filter : Context.getGlobalOptions().LineFilter) {
     if (FileName.endswith(Filter.Name)) {
       if (Filter.LineRanges.empty())
         return true;
       for (const FileFilter::LineRange &Range : Filter.LineRanges) {
         if (Range.first <= LineNumber && LineNumber <= Range.second)
           return true;
       }
       return false;
void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location) {
   // that doesn't have a FileEntry. Don't skip these as well.
   if (!File) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 
   StringRef FileName(File->getName());
+  assert(LastErrorRelatesToUserCode || Sources.isInMainFile(Location) ||
+         HeaderFilter != nullptr);
+  LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
+                               Sources.isInMainFile(Location) ||
+                               HeaderFilter->match(FileName);
+
   unsigned LineNumber = Sources.getExpansionLineNumber(Location);
-  LastErrorRelatesToUserCode |=
-      Sources.isInMainFile(Location) || HeaderFilter.match(FileName);
-  LastErrorPassesLineFilter |= passesLineFilter(FileName, LineNumber);
+  LastErrorPassesLineFilter =
+      LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
 }
 
 namespace {
 struct LessClangTidyError {
   bool operator()(const ClangTidyError *LHS, const ClangTidyError *RHS) const {
     const ClangTidyMessage &M1 = LHS->Message;
     const ClangTidyMessage &M2 = RHS->Message;
 

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
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/system_error.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 
+/// \brief Contains a list of line ranges in a single file.
 struct FileFilter {
+  /// \brief File name.
   std::string Name;
-  // LineRange is a pair<start, end> (inclusive).
+
+  /// \brief LineRange is a pair<start, end> (inclusive).
   typedef std::pair<unsigned, unsigned> LineRange;
+
+  /// \brief A list of line ranges in this file, from where the warnings may be
+  /// displayed.
   std::vector<LineRange> LineRanges;
 };
 
-/// \brief Contains options for clang-tidy.
+/// \brief Global options. These options are nor stored neither read from
+/// configuration files.
+struct ClangTidyGlobalOptions {
+  /// \brief Output warnings from certain line ranges of certain files only. If
+  /// this list is emtpy, it won't be applied.
+  std::vector<FileFilter> LineFilter;
+};
+
+/// \brief Contains options for clang-tidy. These options may be read from
+/// configuration files, and may be different for different translation units.
 struct ClangTidyOptions {
+  /// \brief Allow all checks and no headers by default.
   ClangTidyOptions() : Checks("*"), AnalyzeTemporaryDtors(false) {}
+
+  /// \brief Checks filter.
   std::string Checks;
 
-  // Output warnings from headers matching this filter. Warnings from main files
-  // will always be displayed.
+  /// \brief Output warnings from headers matching this filter. Warnings from
+  /// main files will always be displayed.
   std::string HeaderFilterRegex;
 
-  // Output warnings from certain line ranges of certain files only. If this
-  // list is emtpy, it won't be applied.
-  std::vector<FileFilter> LineFilter;
-
+  /// \brief Turns on temporary destructor-based analysis.
   bool AnalyzeTemporaryDtors;
 };
 
-/// \brief Parses LineFilter from JSON and stores it to the \c Options.
+/// \brief Abstract interface for retrieving various ClangTidy options.
+class ClangTidyOptionsProvider {
+public:
+  virtual ~ClangTidyOptionsProvider() {}
+
+  /// \brief Returns global options, which are independent of the file.
+  virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
+
+  /// \brief Returns options applying to a specific translation unit with the
+  /// specified \p FileName.
+  virtual const ClangTidyOptions &getOptions(llvm::StringRef FileName) = 0;
+};
+
+/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
+/// returns the same options for all files.
+class DefaultOptionsProvider : public ClangTidyOptionsProvider {
+  ClangTidyGlobalOptions GlobalOptions;
+  ClangTidyOptions DefaultOptions;
+
+public:
+  DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
+                         const ClangTidyOptions &Options)
+      : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
+  const ClangTidyGlobalOptions &getGlobalOptions() override {
+    return GlobalOptions;
+  }
+  const ClangTidyOptions &getOptions(llvm::StringRef) override {
+    return DefaultOptions;
+  }
+};
+
+/// \brief Parses LineFilter from JSON and stores it to the \p Options.
 llvm::error_code parseLineFilter(const std::string &LineFilter,
+                                 clang::tidy::ClangTidyGlobalOptions &Options);
+
+/// \brief Parses configuration from JSON and stores it to the \p Options.
+llvm::error_code parseConfiguration(const std::string &Config,
                                     clang::tidy::ClangTidyOptions &Options);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H

clang-tidy/ClangTidyOptions.cpp

 //===--- ClangTidyOptions.cpp - clang-tidy ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyOptions.h"
 #include "llvm/Support/YAMLTraits.h"
 
+using clang::tidy::ClangTidyOptions;
 using clang::tidy::FileFilter;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
 
 namespace llvm {
 namespace yaml {
 
static StringRef validate(IO &io, FileFilter &File) {
     for (const FileFilter::LineRange &Range : File.LineRanges) {
       if (Range.first <= 0 || Range.second <= 0)
         return "Invalid line range";
     }
     return StringRef();
   }
 };
 
+template <> struct MappingTraits<ClangTidyOptions> {
+  static void mapping(IO &IO, ClangTidyOptions &Options) {
+    IO.mapOptional("Checks", Options.Checks);
+    IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
+    IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
+  }
+};
+
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 /// \brief Parses -line-filter option and stores it to the \c Options.
 llvm::error_code parseLineFilter(const std::string &LineFilter,
-                                 clang::tidy::ClangTidyOptions &Options) {
+                                 clang::tidy::ClangTidyGlobalOptions &Options) {
   llvm::yaml::Input Input(LineFilter);
   Input >> Options.LineFilter;
   return Input.error();
 }
 
+llvm::error_code parseConfiguration(const std::string &Config,
+                                    clang::tidy::ClangTidyOptions &Options) {
+  llvm::yaml::Input Input(Config);
+  Input >> Options;
+  return Input.error();
+}
+
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.cpp

if (Stats.ErrorsIgnoredNonUserCode)
       llvm::errs() << "Use -header-filter='.*' to display errors from all "
                       "non-system headers.\n";
   }
 }
 
 int main(int argc, const char **argv) {
   CommonOptionsParser OptionsParser(argc, argv, ClangTidyCategory);
 
-  clang::tidy::ClangTidyOptions Options;
-  Options.Checks = DefaultChecks + Checks;
-  Options.HeaderFilterRegex = HeaderFilter;
-  Options.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+  clang::tidy::ClangTidyGlobalOptions GlobalOptions;
   if (llvm::error_code Err =
-          clang::tidy::parseLineFilter(LineFilter, Options)) {
+          clang::tidy::parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return 1;
   }
 
+  clang::tidy::ClangTidyOptions Options;
+  Options.Checks = DefaultChecks + Checks;
+  Options.HeaderFilterRegex = HeaderFilter;
+  Options.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+
   // FIXME: Allow using --list-checks without positional arguments.
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";
     for (auto CheckName : clang::tidy::getCheckNames(Options))
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
+  // TODO: Implement configuration file reading and a "real" options provider.
+  auto OptionsProvider =
+      new clang::tidy::DefaultOptionsProvider(GlobalOptions, Options);
   std::vector<clang::tidy::ClangTidyError> Errors;
-  clang::tidy::ClangTidyStats Stats =
-      clang::tidy::runClangTidy(Options, OptionsParser.getCompilations(),
-                                OptionsParser.getSourcePathList(), &Errors);
+  clang::tidy::ClangTidyStats Stats = clang::tidy::runClangTidy(
+      OptionsProvider, OptionsParser.getCompilations(),
   clang::tidy::handleErrors(Errors, Fix);
 
   printStats(Stats);
   return 0;
 }
 
 namespace clang {
 namespace tidy {

unittests/clang-tidy/ClangTidyOptionsTest.cpp

 #include "ClangTidyOptions.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace tidy {
 namespace test {
 
 TEST(ParseLineFilter, EmptyFilter) {
-  ClangTidyOptions Options;
+  ClangTidyGlobalOptions Options;
   EXPECT_FALSE(parseLineFilter("", Options));
   EXPECT_TRUE(Options.LineFilter.empty());
   EXPECT_FALSE(parseLineFilter("[]", Options));
   EXPECT_TRUE(Options.LineFilter.empty());
 }
 
 TEST(ParseLineFilter, InvalidFilter) {
-  ClangTidyOptions Options;
+  ClangTidyGlobalOptions Options;
   // TODO: Figure out why parsing succeeds here.
   EXPECT_FALSE(parseLineFilter("asdf", Options));
   EXPECT_TRUE(Options.LineFilter.empty());
 
   EXPECT_TRUE(parseLineFilter("[{}]", Options));
   EXPECT_TRUE(parseLineFilter("[{\"name\":\"\"}]", Options));
   EXPECT_TRUE(
       parseLineFilter("[{\"name\":\"test\",\"lines\":[[1]]}]", Options));
   EXPECT_TRUE(
       parseLineFilter("[{\"name\":\"test\",\"lines\":[[1,2,3]]}]", Options));
   EXPECT_TRUE(
       parseLineFilter("[{\"name\":\"test\",\"lines\":[[1,-1]]}]", Options));
 }
 
 TEST(ParseLineFilter, ValidFilter) {
-  ClangTidyOptions Options;
+  ClangTidyGlobalOptions Options;
   llvm::error_code Error = parseLineFilter(
       "[{\"name\":\"file1.cpp\",\"lines\":[[3,15],[20,30],[42,42]]},"
       "{\"name\":\"file2.h\"},"
       "{\"name\":\"file3.cc\",\"lines\":[[100,1000]]}]",
       Options);
   EXPECT_FALSE(Error);
   EXPECT_EQ(3u, Options.LineFilter.size());
   EXPECT_EQ("file1.cpp", Options.LineFilter[0].Name);
   EXPECT_EQ(3u, Options.LineFilter[0].LineRanges.size());
   EXPECT_EQ(3u, Options.LineFilter[0].LineRanges[0].first);
   EXPECT_EQ(15u, Options.LineFilter[0].LineRanges[0].second);
   EXPECT_EQ(20u, Options.LineFilter[0].LineRanges[1].first);
   EXPECT_EQ(30u, Options.LineFilter[0].LineRanges[1].second);
   EXPECT_EQ(42u, Options.LineFilter[0].LineRanges[2].first);
   EXPECT_EQ(42u, Options.LineFilter[0].LineRanges[2].second);
   EXPECT_EQ("file2.h", Options.LineFilter[1].Name);
   EXPECT_EQ(0u, Options.LineFilter[1].LineRanges.size());
   EXPECT_EQ("file3.cc", Options.LineFilter[2].Name);
   EXPECT_EQ(1u, Options.LineFilter[2].LineRanges.size());
   EXPECT_EQ(100u, Options.LineFilter[2].LineRanges[0].first);
   EXPECT_EQ(1000u, Options.LineFilter[2].LineRanges[0].second);
 }
 
+TEST(ParseConfiguration, ValidConfiguration) {
+  ClangTidyOptions Options;
+  llvm::error_code Error = parseConfiguration("Checks: \"-*,misc-*\"\n"
+                                              "HeaderFilterRegex: \".*\"\n"
+                                              "AnalyzeTemporaryDtors: true\n",
+                                              Options);
+  EXPECT_FALSE(Error);
+  EXPECT_EQ("-*,misc-*", Options.Checks);
+  EXPECT_EQ(".*", Options.HeaderFilterRegex);
+  EXPECT_TRUE(Options.AnalyzeTemporaryDtors);
+}
+
 } // namespace test
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/ClangTidyTest.h

private:
   ClangTidyCheck &Check;
   ClangTidyContext *Context;
 };
 
 template <typename T>
 std::string runCheckOnCode(StringRef Code,
                            std::vector<ClangTidyError> *Errors = nullptr) {
   T Check;
-  ClangTidyOptions Options;
-  ClangTidyContext Context(Options);
+  ClangTidyContext Context(
+      new DefaultOptionsProvider(ClangTidyGlobalOptions(), 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;