Query CompilationDatabase right before running each compilation.

[alexfh]

Summary

Query CompilationDatabase right before running each compilation. This allows
supporting compilation databases that change external state required for
successful compilation.

[djasper]

Looks good.

lib/Tooling/Tooling.cpp

334

Why?

[alexfh]

lib/Tooling/Tooling.cpp

334

You mean inability of clang-format to reflow comments when it breaks long lines? ;)

Did some gq-ing in vim.

include/clang/Tooling/Tooling.h

public:
   int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
 
   /// \brief Returns the file manager used in the tool.
   ///
   /// The file manager is shared between all translation units.
   FileManager &getFiles() { return *Files; }
 
  private:
-  // We store compile commands as pair (file name, compile command).
-  std::vector< std::pair<std::string, CompileCommand> > CompileCommands;
+  const CompilationDatabase &Compilations;
+  std::vector<std::string> SourcePaths;
 
   llvm::IntrusiveRefCntPtr<FileManager> Files;
   // Contains a list of pairs (<file name>, <file content>).
   std::vector< std::pair<StringRef, StringRef> > MappedFileContents;
 
   SmallVector<ArgumentsAdjuster *, 2> ArgsAdjusters;
 
   DiagnosticConsumer *DiagConsumer;

lib/Tooling/Tooling.cpp

bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation,
   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 
   Files->clearStatCaches();
   return Success;
 }
 
 ClangTool::ClangTool(const CompilationDatabase &Compilations,
                      ArrayRef<std::string> SourcePaths)
-    : Files(new FileManager(FileSystemOptions())), DiagConsumer(nullptr) {
+    : Compilations(Compilations), SourcePaths(SourcePaths),
+      Files(new FileManager(FileSystemOptions())), DiagConsumer(nullptr) {
   ArgsAdjusters.push_back(new ClangStripOutputAdjuster());
   ArgsAdjusters.push_back(new ClangSyntaxOnlyAdjuster());
-  for (const auto &SourcePath : SourcePaths) {
-    std::string File(getAbsolutePath(SourcePath));
-
-    std::vector<CompileCommand> CompileCommandsForFile =
-      Compilations.getCompileCommands(File);
-    if (!CompileCommandsForFile.empty()) {
-      for (CompileCommand &CompileCommand : CompileCommandsForFile) {
-        CompileCommands.push_back(
-            std::make_pair(File, std::move(CompileCommand)));
-      }
-    } else {
-      // FIXME: There are two use cases here: doing a fuzzy
-      // "find . -name '*.cc' |xargs tool" match, where as a user I don't care
-      // about the .cc files that were not found, and the use case where I
-      // specify all files I want to run over explicitly, where this should
-      // be an error. We'll want to add an option for this.
-      llvm::errs() << "Skipping " << File << ". Compile command not found.\n";
-    }
-  }
 }
 
 void ClangTool::setDiagnosticConsumer(DiagnosticConsumer *D) {
   DiagConsumer = D;
 }
 
 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
   MappedFileContents.push_back(std::make_pair(FilePath, Content));
int ClangTool::run(ToolAction *Action) {
   // executable.
   // FIXME: On linux, GetMainExecutable is independent of the value of the
   // first argument, thus allowing ClangTool and runToolOnCode to just
   // pass in made-up names here. Make sure this works on other platforms.
   std::string MainExecutable =
       llvm::sys::fs::getMainExecutable("clang_tool", &StaticSymbol);
 
   bool ProcessingFailed = false;
-  for (const auto &Command : CompileCommands) {
+  for (const auto &SourcePath : SourcePaths) {
+    std::string File(getAbsolutePath(SourcePath));
+
+    std::vector<CompileCommand> CompileCommandsForFile =
+        Compilations.getCompileCommands(File);
+    if (CompileCommandsForFile.empty()) {
+      // FIXME: There are two use cases here: doing a fuzzy
+      // "find . -name '*.cc' |xargs tool" match, where as a user I don't care
+      // about the .cc files that were not found, and the use case where I
+      // specify all files I want to run over explicitly, where this should
+      // be an error. We'll want to add an option for this.
+      llvm::errs() << "Skipping " << File << ". Compile command not found.\n";
+      continue;
+    }
+    for (CompileCommand &CompileCommand : CompileCommandsForFile) {
       // FIXME: chdir is thread hostile; on the other hand, creating the same
       // behavior as chdir is complex: chdir resolves the path once, thus
       // guaranteeing that all subsequent relative path operations work
-    // on the same path the original chdir resulted in. This makes a difference
+      // on the same path the original chdir resulted in. This makes a
+      // difference
       // for example on network filesystems, where symlinks might be switched
       // during runtime of the tool. Fixing this depends on having a file system
       // abstraction that allows openat() style interactions.
-    if (chdir(Command.second.Directory.c_str()))
+      if (chdir(CompileCommand.Directory.c_str()))
         llvm::report_fatal_error("Cannot chdir into \"" +
-                               Twine(Command.second.Directory) + "\n!");
-    std::vector<std::string> CommandLine = Command.second.CommandLine;
+                                 Twine(CompileCommand.Directory) + "\n!");
+      std::vector<std::string> CommandLine = CompileCommand.CommandLine;
       for (ArgumentsAdjuster *Adjuster : ArgsAdjusters)
         CommandLine = Adjuster->Adjust(CommandLine);
       assert(!CommandLine.empty());
       CommandLine[0] = MainExecutable;
       // FIXME: We need a callback mechanism for the tool writer to output a
       // customized message for each file.
-    DEBUG({
-      llvm::dbgs() << "Processing: " << Command.first << ".\n";
-    });
+      DEBUG({ llvm::dbgs() << "Processing: " << File << ".\n"; });
       ToolInvocation Invocation(std::move(CommandLine), Action, Files.get());
       Invocation.setDiagnosticConsumer(DiagConsumer);
       for (const auto &MappedFile : MappedFileContents) {
         Invocation.mapVirtualFile(MappedFile.first, MappedFile.second);
       }
       if (!Invocation.run()) {
         // FIXME: Diagnostics should be used instead.
-      llvm::errs() << "Error while processing " << Command.first << ".\n";
+        llvm::errs() << "Error while processing " << File << ".\n";
         ProcessingFailed = true;
       }
     }
+  }
   return ProcessingFailed ? 1 : 0;
 }
 
 namespace {
 
 class ASTBuilderAction : public ToolAction {
   std::vector<std::unique_ptr<ASTUnit>> &ASTs;