[clang][deps] Move stripping of diagnostic serialization from `clang-scan-deps` to `DependencyScanning` library

[jansvoboda11]

Summary

To prevent the creation of diagnostics file, clang-scan-deps strips the corresponding command-line argument. This behavior is useful even when using the C++ DependencyScanner library.

This patch transforms stripping of command-line in clang-scan-deps into stripping of CompilerInvocation in DependencyScanning.

AFAIK, the clang-cl driver doesn't even accept --serialize-diagnostics, so I've removed the test. (It would fail with an unknown command-line argument otherwise.)

Note: Since we're generating command-lines for modular dependencies from CompilerInvocation, the --serialize-diagnostics will be dropped. This was already happening in clang-scan-deps before this patch, but it will now happen also when using DependencyScanning library directly. This is resolved in D104036.

[dexonsmith]

LGTM too.

clang/include/clang/Tooling/ArgumentsAdjusters.h

 /// Gets an argument adjuster that converts input command line arguments
 /// to the "syntax check only" variant.
 ArgumentsAdjuster getClangSyntaxOnlyAdjuster();
 
 /// Gets an argument adjuster which removes output-related command line
 /// arguments.
 ArgumentsAdjuster getClangStripOutputAdjuster();
 
-/// Gets an argument adjuster which removes command line arguments related to
-/// diagnostic serialization.
-ArgumentsAdjuster getClangStripSerializeDiagnosticAdjuster();
-
 /// Gets an argument adjuster which removes dependency-file
 /// related command line arguments.
 ArgumentsAdjuster getClangStripDependencyFileAdjuster();
 
 enum class ArgumentInsertPosition { BEGIN, END };
 
 /// Gets an argument adjuster which inserts \p Extra arguments in the
 /// specified position.

clang/lib/Tooling/ArgumentsAdjusters.cpp

for (size_t i = 0, e = Args.size(); i < e; ++i) {
         ++i;
       }
       // Else, the output is specified as -ofoo. Just do nothing.
     }
     return AdjustedArgs;
   };
 }
 
-ArgumentsAdjuster getClangStripSerializeDiagnosticAdjuster() {
-  return [](const CommandLineArguments &Args, StringRef /*unused*/) {
-    CommandLineArguments AdjustedArgs;
-    for (size_t i = 0, e = Args.size(); i < e; ++i) {
-      StringRef Arg = Args[i];
-      if (Arg == "--serialize-diagnostics") {
-        // Skip the diagnostic output argument.
-        ++i;
-        continue;
-      }
-      AdjustedArgs.push_back(Args[i]);
-    }
-    return AdjustedArgs;
-  };
-}
-
 ArgumentsAdjuster getClangStripDependencyFileAdjuster() {
   return [](const CommandLineArguments &Args, StringRef /*unused*/) {
     auto UsingClDriver = (getDriverMode(Args) == "cl");
 
     CommandLineArguments AdjustedArgs;
     for (size_t i = 0, e = Args.size(); i < e; ++i) {
       StringRef Arg = Args[i];
 

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagConsumer) override {
     // Create a compiler instance to handle the actual work.
     CompilerInstance Compiler(std::move(PCHContainerOps));
     Compiler.setInvocation(std::move(Invocation));
 
     // Don't print 'X warnings and Y errors generated'.
     Compiler.getDiagnosticOpts().ShowCarets = false;
+    // Don't write out diagnostic file.
+    Compiler.getDiagnosticOpts().DiagnosticSerializationFile.clear();
     // Create the compiler's actual diagnostics engine.
     Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
     if (!Compiler.hasDiagnostics())
       return false;
 
     Compiler.getPreprocessorOpts().AllowPCHWithDifferentModulesCachePath = true;
 
     // Use the dependency scanning optimized file system if we can.

clang/test/ClangScanDeps/Inputs/strip_diag_serialize.json

 [
 {
   "directory": "DIR",
   "command": "clang -E -fsyntax-only DIR/strip_diag_serialize_input.cpp --serialize-diagnostics /does/not/exist",
   "file": "DIR/strip_diag_serialize_input.cpp"
-},
-{
-  "directory": "DIR",
-  "command": "clang-cl /E --serialize-diagnostics A:/does/not/exist -- DIR/strip_diag_serialize_input_clangcl.cpp",
-  "file": "DIR/strip_diag_serialize_input_clangcl.cpp"
 }
 ]

clang/test/ClangScanDeps/strip_diag_serialize.cpp

 // RUN: rm -rf %t.dir
 // RUN: rm -rf %t.cdb
 // RUN: mkdir -p %t.dir
 // RUN: cp %s %t.dir/strip_diag_serialize_input.cpp
 // RUN: cp %s %t.dir/strip_diag_serialize_input_clangcl.cpp
 // RUN: sed -e "s|DIR|%/t.dir|g" %S/Inputs/strip_diag_serialize.json > %t.cdb
 //
 // RUN: clang-scan-deps -compilation-database %t.cdb -j 1 2>&1 | FileCheck %s
 // CHECK-NOT: unable to open file
 // CHECK: strip_diag_serialize_input.cpp
-// CHECK: strip_diag_serialize_input_clangcl.cpp
 
 #warning "diagnostic"

clang/tools/clang-scan-deps/ClangScanDeps.cpp

#endif
           if (!ResourceDir.empty()) {
             AdjustedArgs.push_back("-resource-dir");
             AdjustedArgs.push_back(std::string(ResourceDir));
           }
         }
         AdjustedArgs.insert(AdjustedArgs.end(), FlagsEnd, Args.end());
         return AdjustedArgs;
       });
-  AdjustingCompilations->appendArgumentsAdjuster(
-      tooling::getClangStripSerializeDiagnosticAdjuster());
 
   SharedStream Errs(llvm::errs());
   // Print out the dependency results to STDOUT by default.
   SharedStream DependencyOS(llvm::outs());
 
   DependencyScanningService Service(ScanMode, Format, ReuseFileManager,
                                     SkipExcludedPPRanges);
   llvm::ThreadPool Pool(llvm::hardware_concurrency(NumThreads));