[clang-tidy] Use a MemoryBufferRef when parsing configuration files.

[njames93]

Summary

Using a MemoryBufferRef, If there is an error parsing, we can point the user to the location of the file.

[aaron.ballman]

LGTM

clang-tools-extra/clang-tidy/ClangTidyOptions.h

private:
   ClangTidyOptions DefaultOptions;
 };
 
 class FileOptionsBaseProvider : public DefaultOptionsProvider {
 protected:
   // A pair of configuration file base name and a function parsing
   // configuration from text in the corresponding format.
   typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
-                                     llvm::StringRef)>>
+                                     llvm::MemoryBufferRef)>>
       ConfigFileHandler;
 
   /// Configuration file handlers listed in the order of priority.
   ///
   /// Custom configuration file formats can be supported by constructing the
   /// list of handlers and passing it to the appropriate \c FileOptionsProvider
   /// constructor. E.g. initialization of a \c FileOptionsProvider with support
   /// of a custom configuration file format for files named ".my-tidy-config"

 };
 
 /// Parses LineFilter from JSON and stores it to the \p Options.
 std::error_code parseLineFilter(llvm::StringRef LineFilter,
                                 ClangTidyGlobalOptions &Options);
 
 /// Parses configuration from JSON and returns \c ClangTidyOptions or an
 /// error.
-llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
+llvm::ErrorOr<ClangTidyOptions>
+parseConfiguration(llvm::MemoryBufferRef Config);
 
 /// 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_CLANGTIDYOPTIONS_H

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

if (std::error_code EC = Text.getError()) {
       continue;
     }
 
     // Skip empty files, e.g. files opened for writing via shell output
     // redirection.
     if ((*Text)->getBuffer().empty())
       continue;
     llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
-        ConfigHandler.second((*Text)->getBuffer());
+        ConfigHandler.second({(*Text)->getBuffer(), ConfigFile});
     if (!ParsedOptions) {
       if (ParsedOptions.getError())
         llvm::errs() << "Error parsing " << ConfigFile << ": "
                      << ParsedOptions.getError().message() << "\n";
       continue;
     }
     return OptionsSource(*ParsedOptions, std::string(ConfigFile));
   }
   return llvm::None;
 }
 
 /// 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();
 }
 
-llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
+llvm::ErrorOr<ClangTidyOptions>
+parseConfiguration(llvm::MemoryBufferRef Config) {
   llvm::yaml::Input Input(Config);
   ClangTidyOptions Options;
   Input >> Options;
   if (Input.error())
     return Input.error();
   return Options;
 }
 

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

if (HeaderFilter.getNumOccurrences() > 0)
     OverrideOptions.HeaderFilterRegex = HeaderFilter;
   if (SystemHeaders.getNumOccurrences() > 0)
     OverrideOptions.SystemHeaders = SystemHeaders;
   if (FormatStyle.getNumOccurrences() > 0)
     OverrideOptions.FormatStyle = FormatStyle;
   if (UseColor.getNumOccurrences() > 0)
     OverrideOptions.UseColor = UseColor;
 
-  auto LoadConfig = [&](StringRef Configuration)
-      -> std::unique_ptr<ClangTidyOptionsProvider> {
+  auto LoadConfig =
+      [&](StringRef Configuration,
+          StringRef Source) -> std::unique_ptr<ClangTidyOptionsProvider> {
     llvm::ErrorOr<ClangTidyOptions> ParsedConfig =
-        parseConfiguration(Configuration);
+        parseConfiguration(MemoryBufferRef(Configuration, Source));
     if (ParsedConfig)
       return std::make_unique<ConfigOptionsProvider>(
           std::move(GlobalOptions),
           ClangTidyOptions::getDefaults().merge(DefaultOptions, 0),
           std::move(*ParsedConfig), std::move(OverrideOptions), std::move(FS));
     llvm::errs() << "Error: invalid configuration specified.\n"
                  << ParsedConfig.getError().message() << "\n";
     return nullptr;
   };
 
   if (ConfigFile.getNumOccurrences() > 0) {
     if (Config.getNumOccurrences() > 0) {
       llvm::errs() << "Error: --config-file and --config are "
                       "mutually exclusive. Specify only one.\n";
       return nullptr;
     }
 
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
-        llvm::MemoryBuffer::getFile(ConfigFile.c_str());
+        llvm::MemoryBuffer::getFile(ConfigFile);
     if (std::error_code EC = Text.getError()) {
       llvm::errs() << "Error: can't read config-file '" << ConfigFile
                    << "': " << EC.message() << "\n";
       return nullptr;
     }
 
-    return LoadConfig((*Text)->getBuffer());
+    return LoadConfig((*Text)->getBuffer(), ConfigFile);
   }
 
   if (Config.getNumOccurrences() > 0)
-    return LoadConfig(Config);
+    return LoadConfig(Config, "<command-line-config>");
 
   return std::make_unique<FileOptionsProvider>(
       std::move(GlobalOptions), std::move(DefaultOptions),
       std::move(OverrideOptions), std::move(FS));
 }
 
 llvm::IntrusiveRefCntPtr<vfs::FileSystem>
 getVfsFromFile(const std::string &OverlayFile,

clang-tools-extra/clangd/TidyProvider.cpp

public:
   get(const ThreadsafeFS &TFS,
       std::chrono::steady_clock::time_point FreshTime) const {
     std::shared_ptr<const tidy::ClangTidyOptions> Result;
     read(
         TFS, FreshTime,
         [this](llvm::Optional<llvm::StringRef> Data) {
           Value.reset();
           if (Data && !Data->empty()) {
-            if (auto Parsed = tidy::parseConfiguration(*Data))
+            if (auto Parsed = tidy::parseConfiguration(
+                    llvm::MemoryBufferRef(*Data, path())))
               Value = std::make_shared<const tidy::ClangTidyOptions>(
                   std::move(*Parsed));
             else
               elog("Error parsing clang-tidy configuration in {0}: {1}", path(),
                    Parsed.getError().message());
           }
         },
         [&]() { Result = Value; });

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

TEST(ParseLineFilter, ValidFilter) {
   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) {
   llvm::ErrorOr<ClangTidyOptions> Options =
-      parseConfiguration("Checks: \"-*,misc-*\"\n"
+      parseConfiguration(llvm::MemoryBufferRef("Checks: \"-*,misc-*\"\n"
                                                "HeaderFilterRegex: \".*\"\n"
                                                "AnalyzeTemporaryDtors: true\n"
-                         "User: some.user");
+                                               "User: some.user",
+                                               "Options"));
   EXPECT_TRUE(!!Options);
   EXPECT_EQ("-*,misc-*", *Options->Checks);
   EXPECT_EQ(".*", *Options->HeaderFilterRegex);
   EXPECT_EQ("some.user", *Options->User);
 }
 
 TEST(ParseConfiguration, MergeConfigurations) {
-  llvm::ErrorOr<ClangTidyOptions> Options1 = parseConfiguration(R"(
+  llvm::ErrorOr<ClangTidyOptions> Options1 =
+      parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check1,check2"
       HeaderFilterRegex: "filter1"
       AnalyzeTemporaryDtors: true
       User: user1
       ExtraArgs: ['arg1', 'arg2']
       ExtraArgsBefore: ['arg-before1', 'arg-before2']
       UseColor: false
-  )");
+  )",
+                                               "Options1"));
   ASSERT_TRUE(!!Options1);
-  llvm::ErrorOr<ClangTidyOptions> Options2 = parseConfiguration(R"(
+  llvm::ErrorOr<ClangTidyOptions> Options2 =
+      parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check3,check4"
       HeaderFilterRegex: "filter2"
       AnalyzeTemporaryDtors: false
       User: user2
       ExtraArgs: ['arg3', 'arg4']
       ExtraArgsBefore: ['arg-before3', 'arg-before4']
       UseColor: true
-  )");
+  )",
+                                               "Options2"));
   ASSERT_TRUE(!!Options2);
   ClangTidyOptions Options = Options1->merge(*Options2, 0);
   EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
   EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
   EXPECT_EQ("user2", *Options.User);
   ASSERT_TRUE(Options.ExtraArgs.hasValue());
   EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
                                               Options.ExtraArgs->end(), ","));