[clang][deps] Use correct DiagnosticOptions for command-line handling

[jansvoboda11]

Summary

In this patch the dependency scanner starts using proper DiagnosticOptions parsed from the actual TU command-line in order to mimic what the actual compiler would do. The actual functionality will be enabled and tested in follow-up patches. (This split is necessary to avoid temporary regression.)

Depends on D108976.

[dexonsmith]

Code changes LGTM, just a comment on the test.

clang/test/ClangScanDeps/diagnostics.c

8 ↗

(On Diff #369665)

Should this just be:

CHECK-NOT: error:

?

Also, is there a positive CHECK or two you could add? And possibly a comment to explain what the test is for? (It's not obvious to me from the name "diagnostics".)

[jansvoboda11]

Split out tests into a separate patch in order to avoid temporary regression.

[jansvoboda11]

Thanks for the reviews. I had to split out the tests from this patch into D109158 to prevent the temporary regression you pointed out. Your remarks should be addressed there.

[arphaman]

LGTM, thanks

[dexonsmith]

LGTM too, thanks.

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

public:
   ///
   /// \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);
 
 private:
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
   std::unique_ptr<ExcludedPreprocessorDirectiveSkipMapping> PPSkipMappings;
 
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS;
   /// The file system that is used by each worker when scanning for
   /// dependencies. This filesystem persists accross multiple compiler
   /// invocations.
   llvm::IntrusiveRefCntPtr<DependencyScanningWorkerFilesystem> DepFS;

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

private:
   ScanningOutputFormat Format;
 };
 
 } // end anonymous namespace
 
 DependencyScanningWorker::DependencyScanningWorker(
     DependencyScanningService &Service)
     : Format(Service.getFormat()) {
-  DiagOpts = new DiagnosticOptions();
-
   PCHContainerOps = std::make_shared<PCHContainerOperations>();
   PCHContainerOps->registerReader(
       std::make_unique<ObjectFilePCHContainerReader>());
   // We don't need to write object files, but the current PCH implementation
   // requires the writer to be registered as well.
   PCHContainerOps->registerWriter(
       std::make_unique<ObjectFilePCHContainerWriter>());
 
   RealFS = llvm::vfs::createPhysicalFileSystem();
   if (Service.canSkipExcludedPPRanges())
     PPSkipMappings =
         std::make_unique<ExcludedPreprocessorDirectiveSkipMapping>();
   if (Service.getMode() == ScanningMode::MinimizedSourcePreprocessing)
     DepFS = new DependencyScanningWorkerFilesystem(
         Service.getSharedCache(), RealFS, PPSkipMappings.get());
   if (Service.canReuseFileManager())
     Files = new FileManager(FileSystemOptions(), RealFS);
 }
 
-static llvm::Error runWithDiags(
-    DiagnosticOptions *DiagOpts,
-    llvm::function_ref<bool(DiagnosticConsumer &DC)> BodyShouldSucceed) {
+static llvm::Error
+runWithDiags(DiagnosticOptions *DiagOpts,
+             llvm::function_ref<bool(DiagnosticConsumer &, DiagnosticOptions &)>
+                 BodyShouldSucceed) {
+  // Avoid serializing diagnostics.
+  DiagOpts->DiagnosticSerializationFile.clear();
+
   // 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);
 
-  if (BodyShouldSucceed(DiagPrinter))
+  if (BodyShouldSucceed(DiagPrinter, *DiagOpts))
     return llvm::Error::success();
   return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
                                              llvm::inconvertibleErrorCode());
 }
 
 llvm::Error DependencyScanningWorker::computeDependencies(
     StringRef WorkingDirectory, const std::vector<std::string> &CommandLine,
     DependencyConsumer &Consumer) {
   RealFS->setCurrentWorkingDirectory(WorkingDirectory);
 
   llvm::IntrusiveRefCntPtr<FileManager> CurrentFiles =
       Files ? Files : new FileManager(FileSystemOptions(), RealFS);
 
-  return runWithDiags(DiagOpts.get(), [&](DiagnosticConsumer &DC) {
+  std::vector<const char *> CCommandLine(CommandLine.size(), nullptr);
+  llvm::transform(CommandLine, CCommandLine.begin(),
+                  [](const std::string &Str) { return Str.c_str(); });
+
+  return runWithDiags(
+      CreateAndPopulateDiagOpts(CCommandLine).release(),
+      [&](DiagnosticConsumer &DC, DiagnosticOptions &DiagOpts) {
         DependencyScanningAction Action(WorkingDirectory, Consumer, DepFS,
                                         PPSkipMappings.get(), Format);
-    // 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.
+        // 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(CommandLine, &Action, CurrentFiles.get(),
                                   PCHContainerOps);
         Invocation.setDiagnosticConsumer(&DC);
+        Invocation.setDiagnosticOptions(&DiagOpts);
         return Invocation.run();
       });
 }