[clang][deps] NFC: Expose more flexible version of `Worker::computeDependencies()`

[jansvoboda11]

Summary

This patch adds new member function to DependencyScanningWorker that allows clients to pass custom DiagnosticConsumer, and returns bool.

This provides more flexibility compared to the existing version that automatically stringifies diagnostics and returns them in llvm::Error.

clang/include/clang/Tooling/DependencyScanning/DependencyScanningWorker.h

public:
   DependencyScanningWorker(DependencyScanningService &Service,
                            llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
 
   /// Run the dependency scanning tool for a given clang driver command-line,
   /// and report the discovered dependencies to the provided consumer. If \p
   /// ModuleName isn't empty, this function reports the dependencies of module
   /// \p ModuleName.
   ///
+  /// \returns false if clang errors occurred (with diagnostics reported to
+  /// \c DiagConsumer), true otherwise.
+  bool computeDependencies(StringRef WorkingDirectory,
+                           const std::vector<std::string> &CommandLine,
+                           DependencyConsumer &DepConsumer,
+                           DiagnosticConsumer &DiagConsumer,
+                           llvm::Optional<StringRef> ModuleName = None);
   /// \returns A \c StringError with the diagnostic output if clang errors
   /// occurred, success otherwise.
   llvm::Error computeDependencies(StringRef WorkingDirectory,
                                   const std::vector<std::string> &CommandLine,
                                   DependencyConsumer &Consumer,
                                   llvm::Optional<StringRef> ModuleName = None);
 
   bool shouldEagerLoadModules() const { return EagerLoadModules; }

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

DependencyScanningWorker::DependencyScanningWorker(
 
   if (Service.getMode() == ScanningMode::DependencyDirectivesScan)
     DepFS = new DependencyScanningWorkerFilesystem(Service.getSharedCache(),
                                                    RealFS);
   if (Service.canReuseFileManager())
     Files = new FileManager(FileSystemOptions(), RealFS);
 }
 
-static llvm::Error
-runWithDiags(DiagnosticOptions *DiagOpts,
-             llvm::function_ref<bool(DiagnosticConsumer &, DiagnosticOptions &)>
-                 BodyShouldSucceed) {
+llvm::Error DependencyScanningWorker::computeDependencies(
+    StringRef WorkingDirectory, const std::vector<std::string> &CommandLine,
+    DependencyConsumer &Consumer, llvm::Optional<StringRef> ModuleName) {
+  std::vector<const char *> CLI;
+  for (const std::string &Arg : CommandLine)
+    CLI.push_back(Arg.c_str());
+  auto DiagOpts = CreateAndPopulateDiagOpts(CLI);
   sanitizeDiagOpts(*DiagOpts);
 
   // Capture the emitted diagnostics and report them to the client
   // in the case of a failure.
   std::string DiagnosticOutput;
   llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
-  TextDiagnosticPrinter DiagPrinter(DiagnosticsOS, DiagOpts);
+  TextDiagnosticPrinter DiagPrinter(DiagnosticsOS, DiagOpts.release());
 
-  if (BodyShouldSucceed(DiagPrinter, *DiagOpts))
+  if (computeDependencies(WorkingDirectory, CommandLine, Consumer, DiagPrinter,
+                          ModuleName))
     return llvm::Error::success();
   return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
                                              llvm::inconvertibleErrorCode());
 }
 
 static bool forEachDriverJob(
     ArrayRef<std::string> Args, DiagnosticsEngine &Diags, FileManager &FM,
     llvm::function_ref<bool(const driver::Command &Cmd)> Callback) {
static bool forEachDriverJob(
 
   for (const driver::Command &Job : Compilation->getJobs()) {
     if (!Callback(Job))
       return false;
   }
   return true;
 }
 
-llvm::Error DependencyScanningWorker::computeDependencies(
+bool DependencyScanningWorker::computeDependencies(
     StringRef WorkingDirectory, const std::vector<std::string> &CommandLine,
-    DependencyConsumer &Consumer, llvm::Optional<StringRef> ModuleName) {
+    DependencyConsumer &Consumer, DiagnosticConsumer &DC,
+    llvm::Optional<StringRef> ModuleName) {
   // Reset what might have been modified in the previous worker invocation.
   RealFS->setCurrentWorkingDirectory(WorkingDirectory);
   if (Files)
     Files->setVirtualFileSystem(RealFS);
 
   llvm::IntrusiveRefCntPtr<FileManager> CurrentFiles =
       Files ? Files : new FileManager(FileSystemOptions(), RealFS);
 
   Optional<std::vector<std::string>> ModifiedCommandLine;
   if (ModuleName) {
     ModifiedCommandLine = CommandLine;
     InMemoryFS->addFile(*ModuleName, 0, llvm::MemoryBuffer::getMemBuffer(""));
     ModifiedCommandLine->emplace_back(*ModuleName);
   }
 
   const std::vector<std::string> &FinalCommandLine =
       ModifiedCommandLine ? *ModifiedCommandLine : CommandLine;
 
   std::vector<const char *> FinalCCommandLine(CommandLine.size(), nullptr);
   llvm::transform(CommandLine, FinalCCommandLine.begin(),
                   [](const std::string &Str) { return Str.c_str(); });
 
-  return runWithDiags(
-      CreateAndPopulateDiagOpts(FinalCCommandLine).release(),
-      [&](DiagnosticConsumer &DC, DiagnosticOptions &DiagOpts) {
-        IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-            CompilerInstance::createDiagnostics(&DiagOpts, &DC, false);
-        // Although `Diagnostics` are used only for command-line parsing, the
-        // custom `DiagConsumer` might expect a `SourceManager` to be present.
-        SourceManager SrcMgr(*Diags, *CurrentFiles);
-        Diags->setSourceManager(&SrcMgr);
-        // DisableFree is modified by Tooling for running
-        // in-process; preserve the original value, which is
-        // always true for a driver invocation.
-        bool DisableFree = true;
-        DependencyScanningAction Action(WorkingDirectory, Consumer, DepFS,
-                                        Format, OptimizeArgs, EagerLoadModules,
-                                        DisableFree, ModuleName);
-        bool Success = forEachDriverJob(
-            FinalCommandLine, *Diags, *CurrentFiles,
-            [&](const driver::Command &Cmd) {
-              if (StringRef(Cmd.getCreator().getName()) != "clang") {
-                // Non-clang command. Just pass through to the dependency
-                // consumer.
-                Consumer.handleBuildCommand(
-                    {Cmd.getExecutable(),
-                     {Cmd.getArguments().begin(), Cmd.getArguments().end()}});
-                return true;
-              }
+  auto DiagOpts = CreateAndPopulateDiagOpts(FinalCCommandLine);
+  sanitizeDiagOpts(*DiagOpts);
+      CompilerInstance::createDiagnostics(DiagOpts.release(), &DC,
+                                          /*ShouldOwnClient=*/false);
+
+  DependencyScanningAction Action(WorkingDirectory, Consumer, DepFS, Format,
+                                  OptimizeArgs, EagerLoadModules, DisableFree,
+                                  ModuleName);
+      FinalCommandLine, *Diags, *CurrentFiles, [&](const driver::Command &Cmd) {
 
-              std::vector<std::string> Argv;
-              Argv.push_back(Cmd.getExecutable());
-              Argv.insert(Argv.end(), Cmd.getArguments().begin(),
-                          Cmd.getArguments().end());
 
-              // Create an invocation that uses the underlying file
-              // system to ensure that any file system requests that
-              // are made by the driver do not go through the
-              // dependency scanning filesystem.
-              ToolInvocation Invocation(std::move(Argv), &Action,
-                                        &*CurrentFiles, PCHContainerOps);
-              Invocation.setDiagnosticConsumer(Diags->getClient());
-              Invocation.setDiagnosticOptions(&Diags->getDiagnosticOptions());
-              if (!Invocation.run())
-                return false;
+        ToolInvocation Invocation(std::move(Argv), &Action, &*CurrentFiles,
+                                  PCHContainerOps);
 
-              std::vector<std::string> Args = Action.takeLastCC1Arguments();
-              Consumer.handleBuildCommand(
-                  {Cmd.getExecutable(), std::move(Args)});
-              return true;
-            });
+        Consumer.handleBuildCommand({Cmd.getExecutable(), std::move(Args)});
 
-        if (Success && !Action.hasScanned()) {
-          Diags->Report(diag::err_fe_expected_compiler_job)
-              << llvm::join(FinalCommandLine, " ");
-        }
-        return Success && Action.hasScanned();
-      });
+  if (Success && !Action.hasScanned())
 }