[Tooling] Allow to filter files used by AllTUsExecutor

[ilya-biryukov]

Summary

This allows to run clang tools in parallel on a subset of files in the
repository.

[ilya-biryukov]

As discussed offline, instead of changing the interface of AllTUsScheduler, we could add concurrency to StandloneToolExecutor

include/clang/Tooling/AllTUsExecution.h

 /// database.
 class AllTUsToolExecutor : public ToolExecutor {
 public:
   static const char *ExecutorName;
 
   /// Init with \p CompilationDatabase.
   /// This uses \p ThreadCount threads to exececute the actions on all files in
   /// parallel. If \p ThreadCount is 0, this uses `llvm::hardware_concurrency`.
+  /// Only processes files in \p Files. However, if \p Files is empty, will
+  /// process all the files in the compilation database.
   AllTUsToolExecutor(const CompilationDatabase &Compilations,
                      unsigned ThreadCount,
+                     std::vector<std::string> Files = {},
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                          std::make_shared<PCHContainerOperations>());
 
   /// Init with \p CommonOptionsParser. This is expected to be used by
   /// `createExecutorFromCommandLineArgs` based on commandline options.
   ///
   /// The executor takes ownership of \p Options.
   AllTUsToolExecutor(CommonOptionsParser Options, unsigned ThreadCount,
public:
   void mapVirtualFile(StringRef FilePath, StringRef Content) override {
     OverlayFiles[FilePath] = Content;
   }
 
 private:
   // Used to store the parser when the executor is initialized with parser.
   llvm::Optional<CommonOptionsParser> OptionsParser;
   const CompilationDatabase &Compilations;
+  /// A list of files executor should run on. When empty, runs over all the
+  /// files in the compilation database.
+  std::vector<std::string> Files;
   std::unique_ptr<ToolResults> Results;
   ExecutionContext Context;
   llvm::StringMap<std::string> OverlayFiles;
   unsigned ThreadCount;
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_ALLTUSEXECUTION_H

lib/Tooling/AllTUsExecution.cpp

private:
   InMemoryToolResults Results;
   std::mutex Mutex;
 };
 
 } // namespace
 
 AllTUsToolExecutor::AllTUsToolExecutor(
     const CompilationDatabase &Compilations, unsigned ThreadCount,
+    std::vector<std::string> Files,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps)
-    : Compilations(Compilations), Results(new ThreadSafeToolResults),
-      Context(Results.get()), ThreadCount(ThreadCount) {}
+    : Compilations(Compilations), Files(std::move(Files)),
+      Results(new ThreadSafeToolResults), Context(Results.get()),
+      ThreadCount(ThreadCount) {}
 
 AllTUsToolExecutor::AllTUsToolExecutor(
     CommonOptionsParser Options, unsigned ThreadCount,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : OptionsParser(std::move(Options)),
       Compilations(OptionsParser->getCompilations()),
+      Files(OptionsParser->getSourcePathList()),
       Results(new ThreadSafeToolResults), Context(Results.get()),
       ThreadCount(ThreadCount) {}
 
 llvm::Error AllTUsToolExecutor::execute(
     llvm::ArrayRef<
         std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
         Actions) {
   if (Actions.empty())
auto AppendError = [&](llvm::Twine Err) {
     ErrorMsg += Err.str();
   };
 
   auto Log = [&](llvm::Twine Msg) {
     std::unique_lock<std::mutex> LockGuard(TUMutex);
     llvm::errs() << Msg.str() << "\n";
   };
 
-  auto Files = Compilations.getAllFiles();
+  std::vector<std::string> Files =
+      !this->Files.empty() ? this->Files : Compilations.getAllFiles();
   // Add a counter to track the progress.
   const std::string TotalNumStr = std::to_string(Files.size());
   unsigned Counter = 0;
   auto Count = [&]() {
     std::unique_lock<std::mutex> LockGuard(TUMutex);
     return ++Counter;
   };