Provide user name in ClangTidyOptions.

[alexfh]

Summary

This adds the ClangTidyOptions::User field and fills it from the USER
or the USERNAME environment variable, if possible. The FileOptionsProvider now
takes "default" options instead of "fallback" options, as it now uses these when
an option is not set in the configuration file (one exception is the checks
list).

[klimek]

clang-tidy/ClangTidyOptions.h

58

I'd probably default to empty, so checks can decide not to insert something in case there's no user name available.

[alexfh]

Use llvm::None to signal that there's no value for the User setting.

clang-tidy/ClangTidyOptions.h

58

llvm::None would work better for signalling that there's no value available.

[klimek]

lg

clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
   /// 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;
+    Options.User = llvm::None;
     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.
   llvm::Optional<std::string> Checks;
 
   /// \brief Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
   /// \brief Turns on temporary destructor-based analysis.
   llvm::Optional<bool> AnalyzeTemporaryDtors;
 
+  /// \brief Specifies the name or e-mail of the user running clang-tidy.
+  ///
+  /// This option is used, for example, to place the correct user name in TODO()
+  /// comments in the relevant check.
+  llvm::Optional<std::string> User;
+
   typedef std::pair<std::string, std::string> StringPair;
   typedef std::map<std::string, std::string> OptionMap;
 
   /// \brief Key-value mapping used to store check-specific options.
   OptionMap CheckOptions;
 };
 
 /// \brief Abstract interface for retrieving various ClangTidy options.

 /// 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
+  /// \param DefaultOptions are used for all settings not specified in a
   /// .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 &DefaultOptions,
                       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.
+  /// is empty, use the default 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(llvm::StringRef LineFilter,
                                 ClangTidyGlobalOptions &Options);
 
-/// \brief Parses configuration from JSON and stores it to the \p Options.
-std::error_code parseConfiguration(llvm::StringRef Config,
-                                   ClangTidyOptions &Options);
+/// \brief Parses configuration from JSON and returns \c ClangTidyOptions or an
+/// error.
+llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
 
 /// \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

 
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
+    IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
   }
 };
 
 } // 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;
 
   if (Other.HeaderFilterRegex)
     Result.HeaderFilterRegex = Other.HeaderFilterRegex;
   if (Other.AnalyzeTemporaryDtors)
     Result.AnalyzeTemporaryDtors = Other.AnalyzeTemporaryDtors;
+  if (Other.User)
+    Result.User = Other.User;
 
   for (const auto &KeyValue : Other.CheckOptions)
     Result.CheckOptions[KeyValue.first] = KeyValue.second;
 
   return Result;
 }
 
 FileOptionsProvider::FileOptionsProvider(
     const ClangTidyGlobalOptions &GlobalOptions,
-    const ClangTidyOptions &FallbackOptions,
+    const ClangTidyOptions &DefaultOptions,
     const ClangTidyOptions &OverrideOptions)
-    : DefaultOptionsProvider(GlobalOptions, FallbackOptions),
+    : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
       OverrideOptions(OverrideOptions) {
-  CachedOptions[""] = FallbackOptions.mergeWith(OverrideOptions);
+  CachedOptions[""] = DefaultOptions.mergeWith(OverrideOptions);
 }
 
 static const char ConfigFileName[] = ".clang-tidy";
 
 // FIXME: This method has some common logic with clang::format::getStyle().
 // Consider pulling out common bits to a findParentFileWithName function or
 // similar.
 const ClangTidyOptions &FileOptionsProvider::getOptions(StringRef FileName) {
for (StringRef CurrentPath = Path;;
     }
   }
 }
 
 llvm::ErrorOr<ClangTidyOptions>
 FileOptionsProvider::TryReadConfigFile(StringRef Directory) {
   assert(!Directory.empty());
 
-  ClangTidyOptions Options = DefaultOptionsProvider::getOptions(Directory);
   if (!llvm::sys::fs::is_directory(Directory))
     return make_error_code(llvm::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 make_error_code(llvm::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;
   // Skip empty files, e.g. files opened for writing via shell output
   // redirection.
   if ((*Text)->getBuffer().empty())
     return make_error_code(llvm::errc::no_such_file_or_directory);
-  if (std::error_code EC = parseConfiguration((*Text)->getBuffer(), Options))
-    return EC;
-  return Options.mergeWith(OverrideOptions);
+  llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
+      parseConfiguration((*Text)->getBuffer());
+  if (ParsedOptions) {
+    ClangTidyOptions Defaults = DefaultOptionsProvider::getOptions(Directory);
+    // Only use checks from the config file.
+    Defaults.Checks = None;
+    return Defaults.mergeWith(*ParsedOptions).mergeWith(OverrideOptions);
+  }
+  return ParsedOptions.getError();
 }
 
 /// \brief Parses -line-filter option and stores it to the \c Options.
 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(StringRef Config,
-                                   clang::tidy::ClangTidyOptions &Options) {
+llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
   llvm::yaml::Input Input(Config);
+  ClangTidyOptions Options;
   Input >> Options;
+  if (Input.error())
     return Input.error();
+  return Options;
 }
 
 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/google/TodoCommentCheck.h

 namespace readability {
 
 /// \brief Finds TODO comments without a username or bug number.
 ///
 /// Corresponding cpplint.py check: readability/todo
 class TodoCommentCheck : public ClangTidyCheck {
 public:
   TodoCommentCheck(StringRef Name, ClangTidyContext *Context);
-  ~TodoCommentCheck();
   void registerPPCallbacks(CompilerInstance &Compiler) override;
 
 private:
   class TodoCommentHandler;
   std::unique_ptr<TodoCommentHandler> Handler;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_TODOCOMMENTCHECK_H

clang-tidy/google/TodoCommentCheck.cpp

 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 class TodoCommentCheck::TodoCommentHandler : public CommentHandler {
 public:
-  explicit TodoCommentHandler(TodoCommentCheck &Check)
-      : Check(Check), TodoMatch("^// *TODO(\\(.*\\))?:?( )?(.*)$") {}
+  TodoCommentHandler(TodoCommentCheck &Check, llvm::Optional<std::string> User)
+      : Check(Check), User(User ? *User : "unknown"),
+        TodoMatch("^// *TODO(\\(.*\\))?:?( )?(.*)$") {}
 
   bool HandleComment(Preprocessor &PP, SourceRange Range) override {
     StringRef Text =
         Lexer::getSourceText(CharSourceRange::getCharRange(Range),
                              PP.getSourceManager(), PP.getLangOpts());
 
     SmallVector<StringRef, 4> Matches;
     if (!TodoMatch.match(Text, &Matches))
       return false;
 
     StringRef Username = Matches[1];
     StringRef Comment = Matches[3];
 
     if (!Username.empty())
       return false;
 
-    // If the username is missing put in the current user's name. Not ideal but
-    // works for running tidy locally.
-    // FIXME: Can we get this from a more reliable source?
-    const char *User = std::getenv("USER");
-    if (!User)
-      User = "unknown";
     std::string NewText = ("// TODO(" + Twine(User) + "): " + Comment).str();
 
     Check.diag(Range.getBegin(), "missing username/bug in TODO")
         << FixItHint::CreateReplacement(CharSourceRange::getCharRange(Range),
                                         NewText);
     return false;
   }
 
 private:
   TodoCommentCheck &Check;
+  std::string User;
   llvm::Regex TodoMatch;
 };
 
 TodoCommentCheck::TodoCommentCheck(StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
-      Handler(llvm::make_unique<TodoCommentHandler>(*this)) {}
-
-TodoCommentCheck::~TodoCommentCheck() {}
+      Handler(llvm::make_unique<TodoCommentHandler>(
+          *this, Context->getOptions().User)) {}
 
 void TodoCommentCheck::registerPPCallbacks(CompilerInstance &Compiler) {
   Compiler.getPreprocessor().addCommentHandler(Handler.get());
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.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 "../ClangTidy.h"
 #include "clang/Tooling/CommonOptionsParser.h"
+#include "llvm/Support/Process.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 static cl::OptionCategory ClangTidyCategory("clang-tidy options");
 
int clangTidyMain(int argc, const char **argv) {
 
   ClangTidyGlobalOptions GlobalOptions;
   if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return 1;
   }
 
-  ClangTidyOptions FallbackOptions;
-  FallbackOptions.Checks = DefaultChecks;
-  FallbackOptions.HeaderFilterRegex = HeaderFilter;
-  FallbackOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+  ClangTidyOptions DefaultOptions;
+  DefaultOptions.Checks = DefaultChecks;
+  DefaultOptions.HeaderFilterRegex = HeaderFilter;
+  DefaultOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
+  DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
+  // USERNAME is used on Windows.
+  if (!DefaultOptions.User)
+    DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");
 
   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<FileOptionsProvider>(
-      GlobalOptions, FallbackOptions, OverrideOptions);
+      GlobalOptions, DefaultOptions, OverrideOptions);
 
   std::string FileName = OptionsParser.getSourcePathList().front();
   ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FileName);
   std::vector<std::string> EnabledChecks = getCheckNames(EffectiveOptions);
 
   // FIXME: Allow using --list-checks without positional arguments.
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";

unittests/clang-tidy/ClangTidyOptionsTest.cpp

TEST(ParseLineFilter, ValidFilter) {
   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;
-  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);
+  llvm::ErrorOr<ClangTidyOptions> Options =
+      parseConfiguration("Checks: \"-*,misc-*\"\n"
+                         "AnalyzeTemporaryDtors: true\n"
+                         "User: some.user");
+  EXPECT_TRUE(!!Options);
+  EXPECT_EQ("-*,misc-*", *Options->Checks);
+  EXPECT_EQ(".*", *Options->HeaderFilterRegex);
+  EXPECT_TRUE(*Options->AnalyzeTemporaryDtors);
+  EXPECT_EQ("some.user", *Options->User);
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang