[clangd] Add CompileFlags.Compiler option to override argv0

[sammccall]

Summary

This is separate from --query-driver but can combine with it.

Fixes https://github.com/clangd/clangd/issues/642

[kadircet]

thanks!

clang-tools-extra/clangd/ConfigFragment.h

140

not sure if query-driver interactions is worth explaining here

143

i am also afraid of this :/ in theory json compilation database already drops well-known wrappers and users that use another medium to communicate flags should be responsible of taking care of this, so hopefully it won't bite us badly

[sammccall]

clang-tools-extra/clangd/ConfigFragment.h

140

I suspect this is the main reason that people will want to set this :-(
Since they need to get two things right before they see any change, I think some reassurance might help.
We could move this to an external guide though.

143

Yeah. Anyway this is fixable if we need to fix it, it's just annoying to need the list of strings to skip over in two places.

clang-tools-extra/clangd/ConfigCompile.cpp

if (!PathExclude->empty()) {
             return llvm::none_of(*PathExclude, [&](const llvm::Regex &RE) {
               return RE.match(Path);
             });
           });
     }
   }
 
   void compile(Fragment::CompileFlagsBlock &&F) {
+    if (F.Compiler)
+      Out.Apply.push_back(
+          [Compiler(std::move(**F.Compiler))](const Params &, Config &C) {
+            C.CompileFlags.Edits.push_back(
+                [Compiler](std::vector<std::string> &Args) {
+                  if (!Args.empty())
+                    Args.front() = Compiler;
+                });
+          });
+
     if (!F.Remove.empty()) {
       auto Remove = std::make_shared<ArgStripper>();
       for (auto &A : F.Remove)
         Remove->strip(*A);
       Out.Apply.push_back([Remove(std::shared_ptr<const ArgStripper>(
                               std::move(Remove)))](const Params &, Config &C) {
         C.CompileFlags.Edits.push_back(
             [Remove](std::vector<std::string> &Args) {

clang-tools-extra/clangd/ConfigFragment.h

struct Fragment {
   /// By default, it behaves roughly like `clang $FILENAME`, but real projects
   /// usually require setting the include path (with the `-I` flag), defining
   /// preprocessor symbols, configuring warnings etc.
   /// Often, a compilation database specifies these compile commands. clangd
   /// searches for compile_commands.json in parents of the source file.
   ///
   /// This section modifies how the compile command is constructed.
   struct CompileFlagsBlock {
+    /// Override the compiler executable name to simulate.
+    ///
+    /// The name can affect how flags are parsed (clang++ vs clang).
+    /// If the executable name is in the --query-driver allowlist, then it will
+    /// be invoked to extract include paths.
+    ///
+    /// (That this simply replaces argv[0], and may mangle commands that use
+    /// more complicated drivers like ccache).
+    llvm::Optional<Located<std::string>> Compiler;
+
     /// List of flags to append to the compile command.
     std::vector<Located<std::string>> Add;
     /// List of flags to remove from the compile command.
     ///
     /// - If the value is a recognized clang flag (like "-I") then it will be
     ///   removed along with any arguments. Synonyms like --include-dir= will
     ///   also be removed.
     /// - Otherwise, if the value ends in * (like "-DFOO=*") then any argument

clang-tools-extra/clangd/ConfigYAML.cpp

Dict.handle("PathExclude", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.PathExclude = std::move(*Values);
     });
     Dict.parse(N);
   }
 
   void parse(Fragment::CompileFlagsBlock &F, Node &N) {
     DictParser Dict("CompileFlags", this);
+    Dict.handle("Compiler", [&](Node &N) {
+      if (auto Value = scalarValue(N, "Compiler"))
+        F.Compiler = std::move(*Value);
+    });
     Dict.handle("Add", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.Add = std::move(*Values);
     });
     Dict.handle("Remove", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.Remove = std::move(*Values);
     });

clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp

 #ifdef CLANGD_PATH_CASE_INSENSITIVE
   EXPECT_FALSE(compileAndApply());
 #else
   EXPECT_TRUE(compileAndApply());
 #endif
 }
 
 TEST_F(ConfigCompileTests, CompileCommands) {
+  Frag.CompileFlags.Compiler.emplace("tpc.exe");
   Frag.CompileFlags.Add.emplace_back("-foo");
   Frag.CompileFlags.Remove.emplace_back("--include-directory=");
   std::vector<std::string> Argv = {"clang", "-I", "bar/", "--", "a.cc"};
   EXPECT_TRUE(compileAndApply());
-  EXPECT_THAT(Conf.CompileFlags.Edits, SizeIs(2));
+  EXPECT_THAT(Conf.CompileFlags.Edits, SizeIs(3));
   for (auto &Edit : Conf.CompileFlags.Edits)
     Edit(Argv);
-  EXPECT_THAT(Argv, ElementsAre("clang", "-foo", "--", "a.cc"));
+  EXPECT_THAT(Argv, ElementsAre("tpc.exe", "-foo", "--", "a.cc"));
 }
 
 TEST_F(ConfigCompileTests, CompilationDatabase) {
   Frag.CompileFlags.CompilationDatabase.emplace("None");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
             Config::CDBSearchSpec::NoCDBSearch);