Implemented clang-tidy configurability via .clang-tidy files.

[alexfh]

Summary

This adds a support for the .clang-tidy file reading using
FileOptionsProvider, -dump-config option, and changes tests to not depend on
default checks set.

[djasper]

High-level comments.

clang-tidy/ClangTidy.h

122

.... grumble about this being an unrelated cleanup .. grumble ...

clang-tidy/ClangTidyOptions.cpp

83

So currently, this macro makes the code one line longer.. ;-)..

102

Can we pull out code shared with getStyle() in include/clang/Format/Format.h? Seems bad to have this kind of logic in the codebase twice.

clang-tidy/ClangTidyOptions.h

54

Did the default change from "*" to ""? Does that change the behavior?

clang-tidy/tool/ClangTidyMain.cpp

34

Nit: "The effective configuration. .." ?

37

I understand what is happening here, but now it kind of seems that we set default config values at two places.

50

I am not entirely certain that appending is the right thing to do here. But I understand that otherwise, it would be next to impossible to say "everything in the config file +/- this one check". Then again, with -dump-config, it might be easy enough to copy and past the existing active checks for a given file and modify them.

91

Hm. I am wondering whether it really makes sense to keep these individual config flags. The approach in clang-format, where we can just pass in a JSON config through a single flag seems like a good alternative.

[alexfh]

Addressed review comments.

clang-tidy/ClangTidyOptions.cpp

83

Removed it for now. When we have more options. it may become useful again.

102

getStyle differs significantly from this one: it handles languages, default styles, unsuitable configurations etc. This could be abstracted away, but I have no confidence that this will simplify anything. I could try to do this separately from this patch, if you don't mind, so we don't break two tools simultaneously ;)

clang-tidy/ClangTidyOptions.h

54

Yes, but this is a very basic default. It was never used in the command-line use case - there's a separate bunch of defaults in the tool's command-line options. All the code relying on the old default here (unit tests) has been cleaned up.

clang-tidy/tool/ClangTidyMain.cpp

34

Done.

37

The other one (ClangTidyOptions::getDefaults()) is basically a safeguard against unconfigured values for non-command-line use cases (unit tests, etc.).

This one is what the tool actually uses when run from the command line without arguments and finds no .clang-tidy files. There was a plan to remove these defaults and use project-wide .clang-tidy files instead, but I would like to add .clang-tidy files to all relevant projects first.

50

This is done to keep the current behavior. If we want to change it, I'd rather do this as a separate step. And we also need strong reasons to do so, as it would degrade user experience, imo.

91

I'd keep at least the most frequently used options, e.g. -checks:

clang-tidy -config='{Checks: "..."}'

instead of

clang-tidy -checks="..."

is not extremely ugly, but a bit less convenient. Anyways, I'd like to make any unnecessary behavior changes in a separate patch.

[djasper]

clang-tidy/ClangTidyOptions.cpp

83

I think you want to remove the escaped newline.

102

Absolutely, add a FIXME.

FWIW, it might makes sense to just have a function called findParentFileWithName or something that only encapsulates the functionality of walking up directories. Here, this will be sufficient. For clang-format that can then be called in a loop if a certain file is found but unusable.

clang-tidy/tool/ClangTidyMain.cpp

50

This can't be the current behavior as currently, there are no .clang-tidy files. And that's also why I want us to think about it now, before we have to break existing behavior. In your opinion, what are the pros/cons for/against appending?

91

Ok, but what are the more frequently used flags? Also, dumping the current config into a .clang-tidy file and changing that seems like the more convenient way to change these things anyway.

FWIW, I somewhat agree on keeping "-checks" (although I have no data on how frequently it's used). However, I don't thing -analyze-temporary-dtors is or should be a "frequent flag", which is why I left the comment here.

[alexfh]

clang-tidy/ClangTidyOptions.cpp

83

Absolutely.

clang-tidy/tool/ClangTidyMain.cpp

50

The current behavior is that adding -checks=... on the command line modifies the set of checks by appending the new value to the value that would be used without the command line option. The new code behaves exactly in the same way when there's no .clang-tidy file, and naturally extends the same behavior to the case when there is a .clang-tidy file (the "defaults" are taken from the .clang-tidy file instead).

If instead of appending we overwrite the value, we'll change the behavior of clang-tidy in both use cases.

Apart from trying to avoid changes in behavior, I see the following benefit of the current approach: it allows to slightly change the default set of checks as well as completely override it equally easily (use -checks=some-check to add a check to the default set, -checks=-some-check to remove it, -checks=-*,some-check to only run some-check).

91

I totally agree with the idea of removing -analyze-temporary-dtors if we add a command-line option to specify JSON config. The -header-filter= option also doesn't look like a frequently used. However, -checks= is used at least by the check developers and in all our documents, so we'd better leave it.

[alexfh]

Added a FIXME, removed escaped newlines.

[djasper]

Cool, looks good.

clang-tidy/tool/ClangTidyMain.cpp

50

Ok. I am fine with it, I just want to be sure about the implications.

91

Makes sense.

[alexfh]

Closed by commit rL217155 (authored by @alexfh).

clang-tidy/ClangTidy.h

private:
   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(const ClangTidyOptions &Options);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
-///
-/// Takes ownership of the \c OptionsProvider.
 ClangTidyStats
-runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
+runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              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(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

 
 void ClangTidyCheck::setName(StringRef Name) {
   assert(CheckName.empty());
   CheckName = Name.str();
 }
 
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
   clang::tidy::ClangTidyContext Context(
-      new DefaultOptionsProvider(ClangTidyGlobalOptions(), Options));
+      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
+                                                Options));
   ClangTidyASTConsumerFactory Factory(Context);
   return Factory.getCheckNames(Context.getChecksFilter());
 }
 
-ClangTidyStats runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
-                            const tooling::CompilationDatabase &Compilations,
-                            ArrayRef<std::string> InputFiles,
-                            std::vector<ClangTidyError> *Errors) {
+ClangTidyStats
+runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
   ClangTool Tool(Compilations, InputFiles);
-  clang::tidy::ClangTidyContext Context(OptionsProvider);
+  clang::tidy::ClangTidyContext Context(std::move(OptionsProvider));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
     FrontendAction *create() override { return new Action(&ConsumerFactory); }

clang-tidy/ClangTidyDiagnosticConsumer.h

 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
 /// \endcode
 class ClangTidyContext {
 public:
   /// \brief Initializes \c ClangTidyContext instance.
-  ///
-  /// Takes ownership of the \c OptionsProvider.
-  ClangTidyContext(ClangTidyOptionsProvider *OptionsProvider);
+  ClangTidyContext(std::unique_ptr<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,
private:
   /// \brief Store an \p Error.
   void storeError(const ClangTidyError &Error);
 
   std::vector<ClangTidyError> Errors;
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
+  ClangTidyOptions CurrentOptions;
   std::unique_ptr<GlobList> CheckFilter;
 
   ClangTidyStats Stats;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a

clang-tidy/ClangTidyDiagnosticConsumer.cpp

bool GlobList::contains(StringRef S, bool Contains) {
   if (Regex.match(S))
     Contains = Positive;
 
   if (NextGlob)
     Contains = NextGlob->contains(S, Contains);
   return Contains;
 }
 
-ClangTidyContext::ClangTidyContext(ClangTidyOptionsProvider *OptionsProvider)
-    : DiagEngine(nullptr), OptionsProvider(OptionsProvider) {
+ClangTidyContext::ClangTidyContext(
+    std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
+    : DiagEngine(nullptr), OptionsProvider(std::move(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*/) {

 }
 
 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
 void ClangTidyContext::setCurrentFile(StringRef File) {
   CurrentFile = File;
-  CheckFilter.reset(new GlobList(getOptions().Checks));
+  // Safeguard against options with unset values.
+  CurrentOptions = ClangTidyOptions::getDefaults().mergeWith(
+      OptionsProvider->getOptions(CurrentFile));
+  CheckFilter.reset(new GlobList(*getOptions().Checks));
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
   DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
 }
 
 const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
   return OptionsProvider->getGlobalOptions();
 }
 
 const ClangTidyOptions &ClangTidyContext::getOptions() const {
-  return OptionsProvider->getOptions(CurrentFile);
+  return CurrentOptions;
 }
 
 GlobList &ClangTidyContext::getChecksFilter() {
   assert(CheckFilter != nullptr);
   return *CheckFilter;
 }
 
 /// \brief Store a \c ClangTidyError.
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
 
   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));
+  HeaderFilter.reset(new llvm::Regex(*Context.getOptions().HeaderFilterRegex));
 }
 
 bool ClangTidyDiagnosticConsumer::passesLineFilter(StringRef FileName,
                                                    unsigned LineNumber) const {
   if (Context.getGlobalOptions().LineFilter.empty())
     return true;
   for (const FileFilter& Filter : Context.getGlobalOptions().LineFilter) {
     if (FileName.endswith(Filter.Name)) {

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/Optional.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorOr.h"
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 
struct ClangTidyGlobalOptions {
   /// \brief Output warnings from certain line ranges of certain files only.
   /// If empty, no warnings will be filtered.
   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 These options are used for all settings that haven't been
+  /// overridden by the \c OptionsProvider.
+  ///
+  /// Allow no checks and no headers by default.
+  static ClangTidyOptions getDefaults() {
+    ClangTidyOptions Options;
+    Options.Checks = "";
+    Options.HeaderFilterRegex = "";
+    Options.AnalyzeTemporaryDtors = false;
+    return Options;
+  }
+
+  /// \brief Creates a new \c ClangTidyOptions instance combined from all fields
+  /// of this instance overridden by the fields of \p Other that have a value.
+  ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const;
 
   /// \brief Checks filter.
-  std::string Checks;
+  llvm::Optional<std::string> Checks;
 
   /// \brief Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
-  std::string HeaderFilterRegex;
+  llvm::Optional<std::string> HeaderFilterRegex;
 
   /// \brief Turns on temporary destructor-based analysis.
-  bool AnalyzeTemporaryDtors;
+  llvm::Optional<bool> AnalyzeTemporaryDtors;
 };
 
 /// \brief Abstract interface for retrieving various ClangTidy options.
 class ClangTidyOptionsProvider {
 public:
   virtual ~ClangTidyOptionsProvider() {}
 
   /// \brief Returns global options, which are independent of the file.

 class DefaultOptionsProvider : public ClangTidyOptionsProvider {
 public:
   DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
                          const ClangTidyOptions &Options)
       : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
   const ClangTidyGlobalOptions &getGlobalOptions() override {
     return GlobalOptions;
   }
-  const ClangTidyOptions &getOptions(llvm::StringRef) override {
+  const ClangTidyOptions &getOptions(llvm::StringRef /*FileName*/) override {
     return DefaultOptions;
   }
 
 private:
   ClangTidyGlobalOptions GlobalOptions;
   ClangTidyOptions DefaultOptions;
 };
 
+/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
+/// tries to find a .clang-tidy file in the closest parent directory of each
+/// file.
+class FileOptionsProvider : public DefaultOptionsProvider {
+public:
+  /// \brief Initializes the \c FileOptionsProvider instance.
+  ///
+  /// \param GlobalOptions are just stored and returned to the caller of
+  /// \c getGlobalOptions.
+  ///
+  /// \param FallbackOptions are used in case there's no corresponding
+  /// .clang-tidy file.
+  ///
+  /// If any of the \param OverrideOptions fields are set, they will override
+  /// whatever options are read from the configuration file.
+  FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
+                      const ClangTidyOptions &FallbackOptions,
+                      const ClangTidyOptions &OverrideOptions);
+  const ClangTidyOptions &getOptions(llvm::StringRef FileName) override;
+
+private:
+  /// \brief Try to read configuration file from \p Directory. If \p Directory
+  /// is empty, use the fallback value.
+  llvm::ErrorOr<ClangTidyOptions> TryReadConfigFile(llvm::StringRef Directory);
+
+  llvm::StringMap<ClangTidyOptions> CachedOptions;
+  ClangTidyOptions OverrideOptions;
+};
+
 /// \brief Parses LineFilter from JSON and stores it to the \p Options.
-std::error_code parseLineFilter(const std::string &LineFilter,
-                                clang::tidy::ClangTidyGlobalOptions &Options);
+std::error_code parseLineFilter(llvm::StringRef LineFilter,
+                                ClangTidyGlobalOptions &Options);
 
 /// \brief Parses configuration from JSON and stores it to the \p Options.
-std::error_code parseConfiguration(const std::string &Config,
-                                   clang::tidy::ClangTidyOptions &Options);
+std::error_code parseConfiguration(llvm::StringRef Config,
+                                   ClangTidyOptions &Options);
+
+/// \brief Serializes configuration to a YAML-encoded string.
+std::string configurationAsText(const 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 "clang/Basic/LLVM.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/YAMLTraits.h"
+#include <utility>
+
+#define DEBUG_TYPE "clang-tidy-options"
 
 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
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
+ClangTidyOptions
+ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
+  ClangTidyOptions Result = *this;
+
+  // Merge comma-separated glob lists by appending the new value after a comma.
+  if (Other.Checks)
+    Result.Checks =
+        (Result.Checks && !Result.Checks->empty() ? *Result.Checks + "," : "") +
+        *Other.Checks;
+
+#define MERGE_REPLACE(field)                                                   \
+  if (Other.field)                                                             \
+    Result.field = Other.field;
+  MERGE_REPLACE(HeaderFilterRegex);
+  MERGE_REPLACE(AnalyzeTemporaryDtors);
+  return Result;
+}
+
+FileOptionsProvider::FileOptionsProvider(
+    const ClangTidyGlobalOptions &GlobalOptions,
+    const ClangTidyOptions &FallbackOptions,
+    const ClangTidyOptions &OverrideOptions)
+    : DefaultOptionsProvider(GlobalOptions, FallbackOptions),
+      OverrideOptions(OverrideOptions) {
+  CachedOptions[""] = FallbackOptions.mergeWith(OverrideOptions);
+}
+
+static const char ConfigFileName[] = ".clang-tidy";
+
+const ClangTidyOptions &FileOptionsProvider::getOptions(StringRef FileName) {
+  DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
+  SmallString<256> FilePath(FileName);
+
+  if (std::error_code EC = llvm::sys::fs::make_absolute(FilePath)) {
+    llvm::errs() << "Can't make absolute path from " << FileName << ": "
+                 << EC.message() << "\n";
+    // FIXME: Figure out what to do.
+  } else {
+    FileName = FilePath;
+  }
+
+  // Look for a suitable configuration file in all parent directories of the
+  // file. Start with the immediate parent directory and move up.
+  StringRef Path = llvm::sys::path::parent_path(FileName);
+  for (StringRef CurrentPath = Path;;
+       CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
+    llvm::ErrorOr<ClangTidyOptions> Result = std::error_code();
+
+    auto Iter = CachedOptions.find(CurrentPath);
+    if (Iter != CachedOptions.end())
+      Result = Iter->second;
+
+    if (!Result)
+      Result = TryReadConfigFile(CurrentPath);
+
+    if (Result) {
+      // Store cached value for all intermediate directories.
+      while (Path != CurrentPath) {
+        DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
+                           << ".\n");
+        CachedOptions.GetOrCreateValue(Path, *Result);
+        Path = llvm::sys::path::parent_path(Path);
+      }
+      return CachedOptions.GetOrCreateValue(Path, *Result).getValue();
+    }
+    if (Result.getError() != std::errc::no_such_file_or_directory) {
+      llvm::errs() << "Error reading " << ConfigFileName << " from " << Path
+                   << ": " << Result.getError().message() << "\n";
+    }
+  }
+}
+
+llvm::ErrorOr<ClangTidyOptions>
+FileOptionsProvider::TryReadConfigFile(StringRef Directory) {
+  assert(!Directory.empty());
+
+  ClangTidyOptions Options = DefaultOptionsProvider::getOptions(Directory);
+  if (!llvm::sys::fs::is_directory(Directory))
+    return std::errc::not_a_directory;
+
+  SmallString<128> ConfigFile(Directory);
+  llvm::sys::path::append(ConfigFile, ".clang-tidy");
+  DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
+
+  bool IsFile = false;
+  // Ignore errors from is_regular_file: we only need to know if we can read
+  // the file or not.
+  llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
+
+  if (!IsFile)
+    return std::errc::no_such_file_or_directory;
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+      llvm::MemoryBuffer::getFile(ConfigFile.c_str());
+  if (std::error_code EC = Text.getError())
+    return EC;
+  if (std::error_code EC = parseConfiguration((*Text)->getBuffer(), Options))
+    return EC;
+  return Options.mergeWith(OverrideOptions);
+}
+
 /// \brief Parses -line-filter option and stores it to the \c Options.
-std::error_code parseLineFilter(const std::string &LineFilter,
+std::error_code parseLineFilter(StringRef LineFilter,
                                 clang::tidy::ClangTidyGlobalOptions &Options) {
   llvm::yaml::Input Input(LineFilter);
   Input >> Options.LineFilter;
   return Input.error();
 }
 
-std::error_code parseConfiguration(const std::string &Config,
+std::error_code parseConfiguration(StringRef Config,
                                    clang::tidy::ClangTidyOptions &Options) {
   llvm::yaml::Input Input(Config);
   Input >> Options;
   return Input.error();
 }
 
+std::string configurationAsText(const ClangTidyOptions &Options) {
+  std::string Text;
+  llvm::raw_string_ostream Stream(Text);
+  llvm::yaml::Output Output(Stream);
+  // We use the same mapping method for input and output, so we need a non-const
+  // reference here.
+  ClangTidyOptions NonConstValue = Options;
+  Output << NonConstValue;
+  return Stream.str();
+}
+
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.cpp

 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 static cl::OptionCategory ClangTidyCategory("clang-tidy options");
 
 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
+static cl::extrahelp ClangTidyHelp(
+    "Configuration files:\n"
+    "  clang-tidy attempts to read configuration for each source file from a\n"
+    "  .clang-tidy file located in the closest parent directory of the source\n"
+    "  file. If any configuration options have a corresponding command-line\n"
+    "  option, command-line option takes precedence. Effective configuration\n"
+    "  can be inspected using -dump-config.\n\n");
 
 const char DefaultChecks[] =
     "*,"                       // Enable all checks, except these:
     "-clang-analyzer-alpha*,"  // Too many false positives.
     "-llvm-include-order,"     // Not implemented yet.
     "-google-*,";              // Doesn't apply to LLVM.
 
 static cl::opt<std::string>
 Checks("checks", cl::desc("Comma-separated list of globs with optional '-'\n"
                           "prefix. Globs are processed in order of appearance\n"
                           "in the list. Globs without '-' prefix add checks\n"
                           "with matching names to the set, globs with the '-'\n"
                           "prefix remove checks with matching names from the\n"
-                          "set of enabled checks."),
+                          "set of enabled checks.\n"
+                          "This option's value is appended to the value read\n"
+                          "from a .clang-tidy file, if any."),
        cl::init(""), cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string>
 HeaderFilter("header-filter",
              cl::desc("Regular expression matching the names of the\n"
                       "headers to output diagnostics from. Diagnostics\n"
                       "from the main file of each translation unit are\n"
                       "always displayed.\n"
-                      "Can be used together with -line-filter."),
+                      "Can be used together with -line-filter.\n"
+                      "This option overrides the value read from a\n"
+                      ".clang-tidy file."),
              cl::init(""), cl::cat(ClangTidyCategory));
 
 static cl::opt<std::string>
 LineFilter("line-filter",
            cl::desc("List of files with line ranges to filter the\n"
                     "warnings. Can be used together with\n"
                     "-header-filter. The format of the list is a JSON\n"
                     "array of objects:\n"
                     "  [\n"
                     "    {\"name\":\"file1.cpp\",\"lines\":[[1,3],[5,7]]},\n"
                     "    {\"name\":\"file2.h\"}\n"
                     "  ]"),
            cl::init(""), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> Fix("fix", cl::desc("Fix detected errors if possible."),
                          cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool>
 ListChecks("list-checks",
            cl::desc("List all enabled checks and exit. Use with\n"
                     "-checks='*' to list all available checks."),
            cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool>
-AnalyzeTemporaryDtors("analyze-temporary-dtors",
-                      cl::desc("Enable temporary destructor-aware analysis in\n"
-                               "clang-analyzer- checks."),
-                      cl::init(false), cl::cat(ClangTidyCategory));
+DumpConfig("dump-config",
+           cl::desc("Dumps configuration in the YAML format to stdout."),
+           cl::init(false), cl::cat(ClangTidyCategory));
+
+static cl::opt<bool> AnalyzeTemporaryDtors(
+    "analyze-temporary-dtors",
+             "clang-analyzer- checks.\n"
+             "This option overrides the value read from a\n"
+             ".clang-tidy file."),
 
 static void printStats(const clang::tidy::ClangTidyStats &Stats) {
   if (Stats.errorsIgnored()) {
     llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
     StringRef Separator = "";
     if (Stats.ErrorsIgnoredNonUserCode) {
       llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code";
       Separator = ", ";
int main(int argc, const char **argv) {
   clang::tidy::ClangTidyGlobalOptions GlobalOptions;
   if (std::error_code Err =
           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;
-
-  std::vector<std::string> EnabledChecks = clang::tidy::getCheckNames(Options);
+  clang::tidy::ClangTidyOptions FallbackOptions;
+  FallbackOptions.Checks = DefaultChecks;
+  FallbackOptions.HeaderFilterRegex = HeaderFilter;
+  FallbackOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+
+  clang::tidy::ClangTidyOptions OverrideOptions;
+  if (Checks.getNumOccurrences() > 0)
+    OverrideOptions.Checks = Checks;
+  if (HeaderFilter.getNumOccurrences() > 0)
+    OverrideOptions.HeaderFilterRegex = HeaderFilter;
+  if (AnalyzeTemporaryDtors.getNumOccurrences() > 0)
+    OverrideOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+
+  auto OptionsProvider = llvm::make_unique<clang::tidy::FileOptionsProvider>(
+      GlobalOptions, FallbackOptions, OverrideOptions);
+
+  std::string FileName = OptionsParser.getSourcePathList().front();
+  std::vector<std::string> EnabledChecks =
+      clang::tidy::getCheckNames(OptionsProvider->getOptions(FileName));
 
   // FIXME: Allow using --list-checks without positional arguments.
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";
     for (auto CheckName : EnabledChecks)
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
+  if (DumpConfig) {
+    llvm::outs() << clang::tidy::configurationAsText(
+                        clang::tidy::ClangTidyOptions::getDefaults()
+                            .mergeWith(OptionsProvider->getOptions(FileName)))
+                 << "\n";
+    return 0;
+  }
+
   if (EnabledChecks.empty()) {
     llvm::errs() << "Error: no checks enabled.\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return 1;
   }
 
-  // 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(
-      OptionsProvider, OptionsParser.getCompilations(),
+      std::move(OptionsProvider), OptionsParser.getCompilations(),
       OptionsParser.getSourcePathList(), &Errors);
   clang::tidy::handleErrors(Errors, Fix);
 
   printStats(Stats);
   return 0;
 }
 
 namespace clang {

test/clang-tidy/Inputs/config-files/.clang-tidy

+Checks: 'from-parent'
+HeaderFilterRegex: 'parent'
+Checks: 'from-parent'
+HeaderFilterRegex: 'parent'

test/clang-tidy/Inputs/config-files/1/.clang-tidy

+Checks: 'from-child1'
+HeaderFilterRegex: 'child1'
+Checks: 'from-child1'
+HeaderFilterRegex: 'child1'
+Checks: 'from-child1'
+HeaderFilterRegex: 'child1'

test/clang-tidy/config-files.cpp

+// RUN: clang-tidy -dump-config %S/Inputs/config-files/- -- | FileCheck %s -check-prefix=CHECK-BASE
+// CHECK-BASE: Checks: from-parent
+// CHECK-BASE: HeaderFilterRegex: parent
+// RUN: clang-tidy -dump-config %S/Inputs/config-files/1/- -- | FileCheck %s -check-prefix=CHECK-CHILD1
+// CHECK-CHILD1: Checks: from-child1
+// CHECK-CHILD1: HeaderFilterRegex: child1
+// RUN: clang-tidy -dump-config %S/Inputs/config-files/2/- -- | FileCheck %s -check-prefix=CHECK-CHILD2
+// CHECK-CHILD2: Checks: from-parent
+// CHECK-CHILD2: HeaderFilterRegex: parent
+// RUN: clang-tidy -dump-config -checks='from-command-line' -header-filter='from command line' %S/Inputs/config-files/- -- | FileCheck %s -check-prefix=CHECK-COMMAND-LINE
+// CHECK-COMMAND-LINE: Checks: from-parent,from-command-line
+// CHECK-COMMAND-LINE: HeaderFilterRegex: from command line

test/clang-tidy/diagnostic.cpp

 // RUN: clang-tidy -checks='-*,misc-use-override' %s.nonexistent.cpp -- | FileCheck -check-prefix=CHECK1 %s
-// RUN: clang-tidy -checks='-google-*,google-explicit-constructor' %s -- -fan-unknown-option | FileCheck -check-prefix=CHECK2 %s
+// RUN: clang-tidy -checks='-*,clang-diagnostic-*,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='-*,misc-use-override,clang-diagnostic-macro-redefined' %s -- -DMACRO_FROM_COMMAND_LINE | FileCheck -check-prefix=CHECK4 %s
 
 // CHECK1-NOT: warning
 // CHECK2-NOT: warning
 // CHECK3-NOT: warning
 
 // CHECK1: error: error reading '{{.*}}.nonexistent.cpp' [clang-diagnostic-error]

test/clang-tidy/validate-check-names.cpp

+// Check names may only contain alphanumeric characters, '-', '_', and '.'.
+// RUN: clang-tidy -checks=* -list-checks - -- | grep '^    ' | cut -b5- | not grep -v '^[a-zA-Z0-9_.\-]\+$'

unittests/clang-tidy/ClangTidyOptionsTest.cpp

 
 TEST(ParseConfiguration, ValidConfiguration) {
   ClangTidyOptions Options;
   std::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);
+  EXPECT_EQ("-*,misc-*", *Options.Checks);
+  EXPECT_EQ(".*", *Options.HeaderFilterRegex);
+  EXPECT_TRUE(*Options.AnalyzeTemporaryDtors);
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/ClangTidyTest.h

 };
 
 template <typename T>
 std::string runCheckOnCode(StringRef Code,
                            std::vector<ClangTidyError> *Errors = nullptr,
                            const Twine &Filename = "input.cc",
                            ArrayRef<std::string> ExtraArgs = None) {
   T Check;
-  ClangTidyContext Context(
-      new DefaultOptionsProvider(ClangTidyGlobalOptions(), ClangTidyOptions()));
+  ClangTidyOptions Options;
+  Options.Checks = "*";
+  ClangTidyContext Context(llvm::make_unique<DefaultOptionsProvider>(
+      ClangTidyGlobalOptions(), Options));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
   Check.setContext(&Context);
   std::vector<std::string> ArgCXX11(1, "-std=c++11");
   ArgCXX11.insert(ArgCXX11.end(), ExtraArgs.begin(), ExtraArgs.end());
 
   if (!tooling::runToolOnCodeWithArgs(new TestPPAction(Check, &Context), Code,
                                       ArgCXX11, Filename))
     return "";