[clangd] Pass the entire tooling::CompileCommand to CommandMangler

[nridge]

Summary

This gives CommandMangler access to other fields of
tooling::CompileCommand as well, e.g. Directory.

[nridge]

This is a refactoring in preparation for D133757, please see that for motivation

[tom-anders]

clang-tools-extra/clangd/indexer/IndexerMain.cpp

150–158

Just wondering, why do you need to convert to a shared_ptr here? Couldn't the lambda just take ownership of the unique_ptr?

[nridge]

clang-tools-extra/clangd/indexer/IndexerMain.cpp

150–158

ArgumentsAdjuster is a typedef for std::function which needs to be copyable, not move-only

[sammccall]

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

I have a couple of concerns with this interface:

• we seem to be stretching to cover {mangler, querydriver} with one interface, but there's no particular reason to - we never use it polymorphically.
• the contract is very vague. If it's just "mutate flags" then some sort of generic function<void(CompileCommand&)> seems sufficient
• File feels out-of-place - it's purely an input for the mangler. If query-driver needs an extra input, will we add that too?
• either CompileCommand or filename+argv seems reasonable, providing CompileCommand+argv is confusing.
• the name is hard to distinguish from tooling::ArgumentsAdjuster (which is a bad interface)

The immediate problem being solved is the type of CommandMangler::SystemIncludeExtractor, right?
Can that just be unique_function<void(vector<string>&, StringRef)> or so? Possibly behind using SystemIncludeExtractor = ....

[nridge]

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

It's more that QueryDriverDatabase uses the Directory field of tooling::CompileCommand in addition to the arguments.

We could add the directory as another argument to the function, but at that point why not group the arguments into tooling::CompileCommand which is more semantically meaningful?

As for polymorphism vs. unique_function, I don't feel strongly about that, happy to change that up. (I do find function more annoying to debug because step into at a call site in the debugger steps into some hard-to-read library code, but that's probably better solved at the debugger tooling level.)

[nridge]

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

Forgot to mention one other subtlety here: because QueryDriverDatabase needs to operate on a tooling::CompileCommand, the interface between CommandMangler and OverlayCDB needs to be widened to accommodate passing a tooling::CompileCommand, i.e. it can't be ArgumentsAdjuster any more.

This is why I reused CompileCommandsAdjuster as the type used to pass CommandMangler to OverlayCDB, and the type used to pass SystemIncludeExtractor to CommandMangler. It's not used polymorphically, we just need an interface that can accept a CompileCommand in both places; they could be two different types if we prefer.

[nridge]

Updated to use unique_function rather than inheritance

[sammccall]

Sorry about the long turnaround; have had some less-fun-than-code things to deal with :-) Thanks as always for patience...

Main thing I'd still like is to split into two separate function types defined where they're passed, and to drop the File param from the one that doesn't need it.

But stamping it now, land a version of it you're happy with and we can tweak later if need be.

clang-tools-extra/clangd/CompileCommands.h

45–48

while here, can we rename File => TargetFile or something?
Maybe with a comment like "Cmd may describe compilation of a different file, and will be updated for parsing TargetFile"?

(I was confused while reviewing about what Cmd.Filename vs File were used for, and I think I wrote this code :-/)

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

It's more that QueryDriverDatabase uses the Directory field of tooling::CompileCommand in addition to the arguments.

Yes, that makes sense - my concern is providing two filenames the query driver database, which needs none. The first one is semantically clear and the function could potentially use it. The second one is completely meaningless though.

the interface between CommandMangler and OverlayCDB needs to be widened to accommodate passing a tooling::CompileCommand

Right. IIUC the reason we're using these abstract types (as opposed to directly using CommandMangler and some concrete SystemIncludeExtractor) is dependency injection: we don't want OverlayCDB to depend on CommandMangler, or CommandMangler to depend on SystemIncludeExtractor.

For DI, I think we should specify these types independently where they're consumed, i.e.

class OverlayCDB {
  using CommandMangler = unique_function<void(CompileCommand&, StringRef NewFilename)>;
  OverlayCDB(..., CommandMangler M = nullptr);
}

This avoids spurious dependencies in the *other* direction (e.g. CommandMangler should not have to depend on OverlayCDB).
We don't give readers the impression that mangler & extractor are interchangeable somehow.
And things needed by one (e.g if CommandMangler needs 6 more filename params!) needn't affect the other.

(I violated all these ideas in reusing tooling::ArgumentsAdjuster here, it was a mistake)

Ack on the debugger/stacktrace problems with type-erased functions though, I wish I had a good answer.

185

nit: if we're not actually using tooling::ArgumentsAdjuster, I think it'd be clearer not to reuse the name "Adjuster".

Calling this OverlayCDB::CommandMangler/Mangler seems neat to me (it lets a human reader know what's up) but otherwise a synonym like CommandEdits might work?

clang-tools-extra/clangd/indexer/IndexerMain.cpp

150–157

nit: make_shared?

[nridge]

Address review comments

[nridge]

(apologies, I'm also very tardy in getting back to this...)

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

my concern is providing two filenames the query driver database, which needs none

QueryDriverDatabase does in fact use "TargetFile", here.

Based on the usage in OverlayCDB::getCompileCommands(), I don't think we can assume that the File passed to QueryDriverDatabase::getCompileCommand() is the same as the Filename of the CompileCommand that the base CDB returns (otherwise, the mangler could rely on the same assumption and wouldn't need the TargetFile parameter either).

---

Your point about using different unique_function typedefs for CommandMangler and SystemIncludeExtractor, and declaring them close to where they're consumed, makes sense though, I changed that.

[sammccall]

Still LG!

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

QueryDriverDatabase does in fact use "TargetFile", here.

Oops, of course. Well, my preference would be to pass a CompileCommand and just have it reference the filename in there, but happy with what you decide.

I don't think we can assume that the File passed to QueryDriverDatabase::getCompileCommand() is the same as the Filename of the CompileCommand that the base CDB returns (otherwise, the mangler could rely on the same assumption...)

Hmm, I would actually think it must be safe to overwrite Filename with File before calling the mangler. Because we do this already if we transferCompileCommand...

So I'm torn between "let's not work hard to preserve arbitrary implementation details" and "let's not make another subtle change here if we can avoid it" :-\

[nridge]

(I frequently forget that arc diff does not update the commit message of an existing revision...)

[nridge]

clang-tools-extra/clangd/GlobalCompilationDatabase.h

166

I left things as is for now. I can explore simplifying the signature of SystemIncludeExtractor to be just a tooling::CompileCommand in a follow-up patch.

clang-tools-extra/clangd/ClangdLSPServer.cpp

BaseCDB =
         std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
     BaseCDB = getQueryDriverDatabase(llvm::makeArrayRef(Opts.QueryDriverGlobs),
                                      std::move(BaseCDB));
   }
   auto Mangler = CommandMangler::detect();
   if (Opts.ResourceDir)
     Mangler.ResourceDir = *Opts.ResourceDir;
   CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
-              tooling::ArgumentsAdjuster(std::move(Mangler)));
+              std::move(Mangler));
   {
     // Switch caller's context with LSPServer's background context. Since we
     // rather want to propagate information from LSPServer's context into the
     // Server, CDB, etc.
     WithContext MainContext(BackgroundContext.clone());
     llvm::Optional<WithContextValue> WithOffsetEncoding;
     if (Opts.Encoding)
       WithOffsetEncoding.emplace(kCurrentOffsetEncoding, *Opts.Encoding);

clang-tools-extra/clangd/CompileCommands.h

 //===--- CompileCommands.h - Manipulation of compile flags -------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
 
+#include "GlobalCompilationDatabase.h"
 #include "support/Threading.h"
-#include "clang/Tooling/ArgumentsAdjusters.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <deque>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
struct CommandMangler {
   // This is hermetic for unit-tests, but won't work well in production.
   static CommandMangler forTests();
   // Probe the system and build a command-mangler that knows the toolchain.
   //  - try to find clang on $PATH, otherwise fake a path near clangd
   //  - find the resource directory installed near clangd
   //  - on mac, find clang and isysroot by querying the `xcrun` launcher
   static CommandMangler detect();
 
-  void adjust(std::vector<std::string> &Cmd, llvm::StringRef File) const;
-  explicit operator clang::tooling::ArgumentsAdjuster() &&;
+  // `Cmd` may describe compilation of a different file, and will be updated
+  // for parsing `TargetFile`.
+  void operator()(tooling::CompileCommand &Cmd,
+                  llvm::StringRef TargetFile) const;
 
 private:
   CommandMangler() = default;
+
   Memoize<llvm::StringMap<std::string>> ResolvedDrivers;
   Memoize<llvm::StringMap<std::string>> ResolvedDriversNoFollow;
 };
 
 // Removes args from a command-line in a semantically-aware way.
 //
 // Internally this builds a large (0.5MB) table of clang options on first use.
 // Both strip() and process() are fairly cheap after that.

clang-tools-extra/clangd/CompileCommands.cpp

 //===--- CompileCommands.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CompileCommands.h"
 #include "Config.h"
 #include "support/Logger.h"
 #include "support/Trace.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInvocation.h"
-#include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Allocator.h"
CommandMangler CommandMangler::detect() {
   Result.ClangPath = detectClangPath();
   Result.ResourceDir = detectStandardResourceDir();
   Result.Sysroot = detectSysroot();
   return Result;
 }
 
 CommandMangler CommandMangler::forTests() { return CommandMangler(); }
 
-void CommandMangler::adjust(std::vector<std::string> &Cmd,
+void CommandMangler::operator()(tooling::CompileCommand &Command,
                                 llvm::StringRef File) const {
+  std::vector<std::string> &Cmd = Command.CommandLine;
   trace::Span S("AdjustCompileFlags");
   // Most of the modifications below assumes the Cmd starts with a driver name.
   // We might consider injecting a generic driver name like "cc" or "c++", but
   // a Cmd missing the driver is probably rare enough in practice and errnous.
   if (Cmd.empty())
     return;
   auto &OptTable = clang::driver::getDriverOptTable();
   // OriginalArgs needs to outlive ArgList.
if (!Cmd.empty()) {
     Cmd.front() =
         (FollowSymlink ? ResolvedDrivers : ResolvedDriversNoFollow)
             .get(Cmd.front(), [&, this] {
               return resolveDriver(Cmd.front(), FollowSymlink, ClangPath);
             });
   }
 }
 
-CommandMangler::operator clang::tooling::ArgumentsAdjuster() && {
-  // ArgumentsAdjuster is a std::function and so must be copyable.
-  return [Mangler = std::make_shared<CommandMangler>(std::move(*this))](
-             const std::vector<std::string> &Args, llvm::StringRef File) {
-    auto Result = Args;
-    Mangler->adjust(Result, File);
-    return Result;
-  };
-}
-
 // ArgStripper implementation
 namespace {
 
 // Determine total number of args consumed by this option.
 // Return answers for {Exact, Prefix} match. 0 means not allowed.
 std::pair<unsigned, unsigned> getArgCount(const llvm::opt::Option &Opt) {
   constexpr static unsigned Rest = 10000; // Should be all the rest!
   // Reference is llvm::opt::Option::acceptInternal()

clang-tools-extra/clangd/GlobalCompilationDatabase.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_GLOBALCOMPILATIONDATABASE_H
 
 #include "support/Function.h"
 #include "support/Path.h"
 #include "support/Threading.h"
 #include "support/ThreadsafeFS.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include <memory>
 #include <mutex>
 #include <vector>
 
 namespace clang {
 namespace clangd {
private:
   void broadcastCDB(CDBLookupResult Res) const;
 
   // cache test calls lookupCDB directly to ensure valid/invalid times.
   friend class DirectoryBasedGlobalCompilationDatabaseCacheTest;
 };
 
 /// Extracts system include search path from drivers matching QueryDriverGlobs
 /// and adds them to the compile flags. Base may not be nullptr.
 /// Returns Base when \p QueryDriverGlobs is empty.
 std::unique_ptr<GlobalCompilationDatabase>
 getQueryDriverDatabase(llvm::ArrayRef<std::string> QueryDriverGlobs,
                        std::unique_ptr<GlobalCompilationDatabase> Base);
 
 /// Wraps another compilation database, and supports overriding the commands
 /// using an in-memory mapping.
 class OverlayCDB : public DelegatingCDB {
 public:
+  // Makes adjustments to a tooling::CompileCommand which will be used to
+  // process a file (possibly different from the one in the command).
+  using CommandMangler = llvm::unique_function<void(tooling::CompileCommand &,
+                                                    StringRef File) const>;
+
   // Base may be null, in which case no entries are inherited.
   // FallbackFlags are added to the fallback compile command.
   // Adjuster is applied to all commands, fallback or not.
   OverlayCDB(const GlobalCompilationDatabase *Base,
              std::vector<std::string> FallbackFlags = {},
-             tooling::ArgumentsAdjuster Adjuster = nullptr);
+             CommandMangler Mangler = nullptr);
 
   llvm::Optional<tooling::CompileCommand>
   getCompileCommand(PathRef File) const override;
   tooling::CompileCommand getFallbackCommand(PathRef File) const override;
 
   /// Sets or clears the compilation command for a particular file.
   void
   setCompileCommand(PathRef File,
                     llvm::Optional<tooling::CompileCommand> CompilationCommand);
 
 private:
   mutable std::mutex Mutex;
   llvm::StringMap<tooling::CompileCommand> Commands; /* GUARDED_BY(Mut) */
-  tooling::ArgumentsAdjuster ArgsAdjuster;
+  CommandMangler Mangler;
   std::vector<std::string> FallbackFlags;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_GLOBALCOMPILATIONDATABASE_H

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

DirectoryBasedGlobalCompilationDatabase::getProjectInfo(PathRef File) const {
   auto Res = lookupCDB(Req);
   if (!Res)
     return llvm::None;
   return Res->PI;
 }
 
 OverlayCDB::OverlayCDB(const GlobalCompilationDatabase *Base,
                        std::vector<std::string> FallbackFlags,
-                       tooling::ArgumentsAdjuster Adjuster)
-    : DelegatingCDB(Base), ArgsAdjuster(std::move(Adjuster)),
+                       CommandMangler Mangler)
+    : DelegatingCDB(Base), Mangler(std::move(Mangler)),
       FallbackFlags(std::move(FallbackFlags)) {}
 
 llvm::Optional<tooling::CompileCommand>
 OverlayCDB::getCompileCommand(PathRef File) const {
   llvm::Optional<tooling::CompileCommand> Cmd;
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     auto It = Commands.find(removeDots(File));
     if (It != Commands.end())
       Cmd = It->second;
   }
   if (!Cmd)
     Cmd = DelegatingCDB::getCompileCommand(File);
   if (!Cmd)
     return llvm::None;
-  if (ArgsAdjuster)
-    Cmd->CommandLine = ArgsAdjuster(Cmd->CommandLine, File);
+  if (Mangler)
+    Mangler(*Cmd, File);
   return Cmd;
 }
 
 tooling::CompileCommand OverlayCDB::getFallbackCommand(PathRef File) const {
   auto Cmd = DelegatingCDB::getFallbackCommand(File);
   std::lock_guard<std::mutex> Lock(Mutex);
   Cmd.CommandLine.insert(Cmd.CommandLine.end(), FallbackFlags.begin(),
                          FallbackFlags.end());
-  if (ArgsAdjuster)
-    Cmd.CommandLine = ArgsAdjuster(Cmd.CommandLine, File);
+  if (Mangler)
+    Mangler(Cmd, File);
   return Cmd;
 }
 
 void OverlayCDB::setCompileCommand(
     PathRef File, llvm::Optional<tooling::CompileCommand> Cmd) {
   // We store a canonical version internally to prevent mismatches between set
   // and get compile commands. Also it assures clients listening to broadcasts
   // doesn't receive different names for the same file.

clang-tools-extra/clangd/indexer/IndexerMain.cpp

if (!Executor) {
     return 1;
   }
 
   // Collect symbols found in each translation unit, merging as we go.
   clang::clangd::IndexFileIn Data;
   auto Err = Executor->get()->execute(
       std::make_unique<clang::clangd::IndexActionFactory>(Data),
       clang::tooling::ArgumentsAdjuster(
-          clang::clangd::CommandMangler::detect()));
+          [Mangler = std::make_shared<clang::clangd::CommandMangler>(
+               clang::clangd::CommandMangler::detect())](
+              const std::vector<std::string> &Args, llvm::StringRef File) {
+            clang::tooling::CompileCommand Cmd;
+            Cmd.CommandLine = Args;
+            Mangler->operator()(Cmd, File);
+            return Cmd.CommandLine;
+          }));
   if (Err) {
     clang::clangd::elog("{0}", std::move(Err));
   }
 
   // Emit collected data.
   clang::clangd::IndexFileOut Out(Data);
   Out.Format = clang::clangd::Format;
   llvm::outs() << Out;
   return 0;
 }

clang-tools-extra/clangd/tool/Check.cpp

bool buildCommand(const ThreadsafeFS &TFS) {
     std::unique_ptr<GlobalCompilationDatabase> BaseCDB =
         std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
     BaseCDB = getQueryDriverDatabase(llvm::makeArrayRef(Opts.QueryDriverGlobs),
                                      std::move(BaseCDB));
     auto Mangler = CommandMangler::detect();
     if (Opts.ResourceDir)
       Mangler.ResourceDir = *Opts.ResourceDir;
     auto CDB = std::make_unique<OverlayCDB>(
-        BaseCDB.get(), std::vector<std::string>{},
-        tooling::ArgumentsAdjuster(std::move(Mangler)));
+        BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler));
 
     if (auto TrueCmd = CDB->getCompileCommand(File)) {
       Cmd = std::move(*TrueCmd);
       log("Compile command {0} is: {1}",
           Cmd.Heuristic.empty() ? "from CDB" : Cmd.Heuristic,
           printArgv(Cmd.CommandLine));
     } else {
       Cmd = CDB->getFallbackCommand(File);

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

Opts.ContextProvider = [](PathRef P) {
     return Context::current().derive(Config::Key, std::move(C));
   };
   // Create the background index.
   llvm::StringMap<std::string> Storage;
   size_t CacheHits = 0;
   MemoryShardStorage MSS(Storage, CacheHits);
   // We need the CommandMangler, because that applies the config we're testing.
   OverlayCDB CDB(/*Base=*/nullptr, /*FallbackFlags=*/{},
-                 tooling::ArgumentsAdjuster(CommandMangler::forTests()));
+                 CommandMangler::forTests());
 
   BackgroundIndex Idx(
       FS, CDB, [&](llvm::StringRef) { return &MSS; }, std::move(Opts));
   // Index the two files.
   for (auto &Cmd : Cmds) {
     std::string FullPath = testPath(Cmd.Filename);
     CDB.setCompileCommand(FullPath, std::move(Cmd));
   }

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

getFragments(const config::Params &,
       return {std::move(F).compile(DC)};
     }
   } CfgProvider;
 
   auto Opts = ClangdServer::optsForTest();
   Opts.ContextProvider =
       ClangdServer::createConfiguredContextProvider(&CfgProvider, nullptr);
   OverlayCDB CDB(/*Base=*/nullptr, /*FallbackFlags=*/{},
-                 tooling::ArgumentsAdjuster(CommandMangler::forTests()));
+                 CommandMangler::forTests());
   MockFS FS;
   ClangdServer Server(CDB, FS, Opts);
   // foo.cc sees the expected definition, as FOO is defined.
   Server.addDocument(testPath("foo.cc"), Example.code());
   auto Result = runLocateSymbolAt(Server, testPath("foo.cc"), Example.point());
   ASSERT_TRUE(bool(Result)) << Result.takeError();
   ASSERT_THAT(*Result, SizeIs(1));
   EXPECT_EQ(Result->front().PreferredDeclaration.range, Example.range());

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

 
 // Make use of all features and assert the exact command we get out.
 // Other tests just verify presence/absence of certain args.
 TEST(CommandMangler, Everything) {
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");
   Mangler.ResourceDir = testPath("fake/resources");
   Mangler.Sysroot = testPath("fake/sysroot");
-  std::vector<std::string> Cmd = {"clang++", "--", "foo.cc", "bar.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_THAT(Cmd, ElementsAre(testPath("fake/clang++"),
-                               "-resource-dir=" + testPath("fake/resources"),
-                               "-isysroot", testPath("fake/sysroot"), "--",
-                               "foo.cc"));
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang++", "--", "foo.cc", "bar.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_THAT(Cmd.CommandLine,
+              ElementsAre(testPath("fake/clang++"),
 }
 
 TEST(CommandMangler, FilenameMismatch) {
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("clang");
   // Our compile flags refer to foo.cc...
-  std::vector<std::string> Cmd = {"clang", "foo.cc"};
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang", "foo.cc"};
   // but we're applying it to foo.h...
-  Mangler.adjust(Cmd, "foo.h");
+  Mangler(Cmd, "foo.h");
   // so transferCompileCommand should add -x c++-header to preserve semantics.
-  EXPECT_THAT(
-      Cmd, ElementsAre(testPath("clang"), "-x", "c++-header", "--", "foo.h"));
+  EXPECT_THAT(Cmd.CommandLine, ElementsAre(testPath("clang"), "-x",
+                                           "c++-header", "--", "foo.h"));
 }
 
 TEST(CommandMangler, ResourceDir) {
   auto Mangler = CommandMangler::forTests();
   Mangler.ResourceDir = testPath("fake/resources");
-  std::vector<std::string> Cmd = {"clang++", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_THAT(Cmd, Contains("-resource-dir=" + testPath("fake/resources")));
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang++", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_THAT(Cmd.CommandLine,
+              Contains("-resource-dir=" + testPath("fake/resources")));
 }
 
 TEST(CommandMangler, Sysroot) {
   auto Mangler = CommandMangler::forTests();
   Mangler.Sysroot = testPath("fake/sysroot");
 
-  std::vector<std::string> Cmd = {"clang++", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_THAT(llvm::join(Cmd, " "),
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang++", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_THAT(llvm::join(Cmd.CommandLine, " "),
               HasSubstr("-isysroot " + testPath("fake/sysroot")));
 }
 
 TEST(CommandMangler, ClangPath) {
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");
 
-  std::vector<std::string> Cmd = {"clang++", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_EQ(testPath("fake/clang++"), Cmd.front());
-
-  Cmd = {"unknown-binary", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_EQ(testPath("fake/unknown-binary"), Cmd.front());
-
-  Cmd = {testPath("path/clang++"), "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_EQ(testPath("path/clang++"), Cmd.front());
-
-  Cmd = {"foo/unknown-binary", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_EQ("foo/unknown-binary", Cmd.front());
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang++", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_EQ(testPath("fake/clang++"), Cmd.CommandLine.front());
+
+  Cmd.CommandLine = {"unknown-binary", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_EQ(testPath("fake/unknown-binary"), Cmd.CommandLine.front());
+
+  Cmd.CommandLine = {testPath("path/clang++"), "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_EQ(testPath("path/clang++"), Cmd.CommandLine.front());
+
+  Cmd.CommandLine = {"foo/unknown-binary", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_EQ("foo/unknown-binary", Cmd.CommandLine.front());
 }
 
 // Only run the PATH/symlink resolving test on unix, we need to fiddle
 // with permissions and environment variables...
 #ifdef LLVM_ON_UNIX
 MATCHER(ok, "") {
   if (arg) {
     *result_listener << arg.message();
TEST(CommandMangler, ClangPathResolve) {
   ::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable
   ASSERT_THAT(
       llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"),
       ok());
 
   // Test the case where the driver is an absolute path to a symlink.
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");
-  std::vector<std::string> Cmd = {(TempDir + "/bin/foo").str(), "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {(TempDir + "/bin/foo").str(), "foo.cc"};
+  Mangler(Cmd, "foo.cc");
   // Directory based on resolved symlink, basename preserved.
-  EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.front());
+  EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front());
 
   // Set PATH to point to temp/bin so we can find 'foo' on it.
   ASSERT_TRUE(::getenv("PATH"));
   auto RestorePath =
       llvm::make_scope_exit([OldPath = std::string(::getenv("PATH"))] {
         ::setenv("PATH", OldPath.c_str(), 1);
       });
   ::setenv("PATH", (TempDir + "/bin").str().c_str(), /*overwrite=*/1);
 
   // Test the case where the driver is a $PATH-relative path to a symlink.
   Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");
   // Driver found on PATH.
-  Cmd = {"foo", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
+  Cmd.CommandLine = {"foo", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
   // Found the symlink and resolved the path as above.
-  EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.front());
+  EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.CommandLine.front());
 
   // Symlink not resolved with -no-canonical-prefixes.
-  Cmd = {"foo", "-no-canonical-prefixes", "foo.cc"};
-  Mangler.adjust(Cmd, "foo.cc");
-  EXPECT_EQ((TempDir + "/bin/foo").str(), Cmd.front());
+  Cmd.CommandLine = {"foo", "-no-canonical-prefixes", "foo.cc"};
+  Mangler(Cmd, "foo.cc");
+  EXPECT_EQ((TempDir + "/bin/foo").str(), Cmd.CommandLine.front());
 }
 #endif
 
 TEST(CommandMangler, ConfigEdits) {
   auto Mangler = CommandMangler::forTests();
-  std::vector<std::string> Cmd = {"clang++", "foo.cc"};
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang++", "foo.cc"};
   {
     Config Cfg;
     Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) {
       for (auto &Arg : Argv)
         for (char &C : Arg)
           C = llvm::toUpper(C);
     });
     Cfg.CompileFlags.Edits.push_back([](std::vector<std::string> &Argv) {
       Argv = tooling::getInsertArgumentAdjuster("--hello")(Argv, "");
     });
     WithContextValue WithConfig(Config::Key, std::move(Cfg));
-    Mangler.adjust(Cmd, "foo.cc");
+    Mangler(Cmd, "foo.cc");
   }
   // Edits are applied in given order and before other mangling and they always
   // go before filename.
-  EXPECT_THAT(Cmd, ElementsAre(_, "--hello", "--", "FOO.CC"));
+  EXPECT_THAT(Cmd.CommandLine, ElementsAre(_, "--hello", "--", "FOO.CC"));
 }
 
 static std::string strip(llvm::StringRef Arg, llvm::StringRef Argv) {
   llvm::SmallVector<llvm::StringRef> Parts;
   llvm::SplitString(Argv, Parts);
   std::vector<std::string> Args = {Parts.begin(), Parts.end()};
   ArgStripper S;
   S.strip(Arg);
TEST(PrintArgvTest, All) {
   };
   const char *Expected = R"(one two "thr ee" "f\"o\"ur" "fi\\ve" $)";
   EXPECT_EQ(Expected, printArgv(Args));
 }
 
 TEST(CommandMangler, InputsAfterDashDash) {
   const auto Mangler = CommandMangler::forTests();
   {
-    std::vector<std::string> Args = {"clang", "/Users/foo.cc"};
-    Mangler.adjust(Args, "/Users/foo.cc");
-    EXPECT_THAT(llvm::makeArrayRef(Args).take_back(2),
+    tooling::CompileCommand Cmd;
+    Cmd.CommandLine = {"clang", "/Users/foo.cc"};
+    Mangler(Cmd, "/Users/foo.cc");
+    EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2),
                 ElementsAre("--", "/Users/foo.cc"));
-    EXPECT_THAT(llvm::makeArrayRef(Args).drop_back(2),
+    EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).drop_back(2),
                 Not(Contains("/Users/foo.cc")));
   }
   // In CL mode /U triggers an undef operation, hence `/Users/foo.cc` shouldn't
   // be interpreted as a file.
   {
-    std::vector<std::string> Args = {"clang", "--driver-mode=cl", "bar.cc",
-                                     "/Users/foo.cc"};
-    Mangler.adjust(Args, "bar.cc");
-    EXPECT_THAT(llvm::makeArrayRef(Args).take_back(2),
+    tooling::CompileCommand Cmd;
+    Cmd.CommandLine = {"clang", "--driver-mode=cl", "bar.cc", "/Users/foo.cc"};
+    Mangler(Cmd, "bar.cc");
+    EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2),
                 ElementsAre("--", "bar.cc"));
-    EXPECT_THAT(llvm::makeArrayRef(Args).drop_back(2), Not(Contains("bar.cc")));
+    EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).drop_back(2),
+                Not(Contains("bar.cc")));
   }
   // All inputs but the main file is dropped.
   {
-    std::vector<std::string> Args = {"clang", "foo.cc", "bar.cc"};
-    Mangler.adjust(Args, "baz.cc");
-    EXPECT_THAT(llvm::makeArrayRef(Args).take_back(2),
+    tooling::CompileCommand Cmd;
+    Cmd.CommandLine = {"clang", "foo.cc", "bar.cc"};
+    Mangler(Cmd, "baz.cc");
+    EXPECT_THAT(llvm::makeArrayRef(Cmd.CommandLine).take_back(2),
                 ElementsAre("--", "baz.cc"));
     EXPECT_THAT(
-        llvm::makeArrayRef(Args).drop_back(2),
+        llvm::makeArrayRef(Cmd.CommandLine).drop_back(2),
         testing::AllOf(Not(Contains("foo.cc")), Not(Contains("bar.cc"))));
   }
 }
 
 TEST(CommandMangler, StripsMultipleArch) {
   const auto Mangler = CommandMangler::forTests();
-  std::vector<std::string> Args = {"clang", "-arch", "foo",
-                                   "-arch", "bar",   "/Users/foo.cc"};
-  Mangler.adjust(Args, "/Users/foo.cc");
-  EXPECT_EQ(
-      llvm::count_if(Args, [](llvm::StringRef Arg) { return Arg == "-arch"; }),
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {"clang", "-arch", "foo", "-arch", "bar", "/Users/foo.cc"};
+  Mangler(Cmd, "/Users/foo.cc");
+  EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
+                           [](llvm::StringRef Arg) { return Arg == "-arch"; }),
             0);
 
   // Single arch option is preserved.
-  Args = {"clang", "-arch", "foo", "/Users/foo.cc"};
-  Mangler.adjust(Args, "/Users/foo.cc");
-  EXPECT_EQ(
-      llvm::count_if(Args, [](llvm::StringRef Arg) { return Arg == "-arch"; }),
+  Cmd.CommandLine = {"clang", "-arch", "foo", "/Users/foo.cc"};
+  Mangler(Cmd, "/Users/foo.cc");
+  EXPECT_EQ(llvm::count_if(Cmd.CommandLine,
+                           [](llvm::StringRef Arg) { return Arg == "-arch"; }),
             1);
 }
 
 TEST(CommandMangler, EmptyArgs) {
   const auto Mangler = CommandMangler::forTests();
-  std::vector<std::string> Args = {};
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {};
   // Make sure we don't crash.
-  Mangler.adjust(Args, "foo.cc");
+  Mangler(Cmd, "foo.cc");
 }
 
 TEST(CommandMangler, PathsAsPositional) {
   const auto Mangler = CommandMangler::forTests();
-  std::vector<std::string> Args = {
+  tooling::CompileCommand Cmd;
+  Cmd.CommandLine = {
       "clang",
       "--driver-mode=cl",
       "-I",
       "foo",
   };
   // Make sure we don't crash.
-  Mangler.adjust(Args, "a.cc");
-  EXPECT_THAT(Args, Contains("foo"));
+  Mangler(Cmd, "a.cc");
+  EXPECT_THAT(Cmd.CommandLine, Contains("foo"));
 }
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST_F(OverlayCDBTest, Watch) {
   Inner.setCompileCommand("A.cpp", llvm::None);
   Outer.setCompileCommand("C.cpp", llvm::None);
   EXPECT_THAT(Changes, ElementsAre(ElementsAre("A.cpp"), ElementsAre("B.cpp"),
                                    ElementsAre("A.cpp"), ElementsAre("C.cpp")));
 }
 
 TEST_F(OverlayCDBTest, Adjustments) {
   OverlayCDB CDB(Base.get(), {"-DFallback"},
-                 [](const std::vector<std::string> &Cmd, llvm::StringRef File) {
-                   auto Ret = Cmd;
-                   Ret.push_back(
+                 [](tooling::CompileCommand &Cmd, llvm::StringRef File) {
+                   Cmd.CommandLine.push_back(
                        ("-DAdjust_" + llvm::sys::path::filename(File)).str());
-                   return Ret;
                  });
   // Command from underlying gets adjusted.
   auto Cmd = *CDB.getCompileCommand(testPath("foo.cc"));
   EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=1", testPath("foo.cc"),
                                            "-DAdjust_foo.cc"));
 
   // Command from overlay gets adjusted.
   tooling::CompileCommand BarCommand;

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

if (ImplicitHeaderGuard)
       Inputs.CompileCommand.CommandLine.push_back("-fno-ms-compatibility");
   }
   Argv.insert(Argv.end(), ExtraArgs.begin(), ExtraArgs.end());
   // Put the file name at the end -- this allows the extra arg (-xc++) to
   // override the language setting.
   Argv.push_back(FullFilename);
 
   auto Mangler = CommandMangler::forTests();
-  Mangler.adjust(Inputs.CompileCommand.CommandLine, FullFilename);
+  Mangler(Inputs.CompileCommand, FullFilename);
   Inputs.CompileCommand.Filename = FullFilename;
   Inputs.CompileCommand.Directory = testRoot();
   Inputs.Contents = Code;
   if (OverlayRealFileSystemForModules)
     FS.OverlayRealFileSystemForModules = true;
   Inputs.TFS = &FS;
   Inputs.Opts = ParseOptions();
   if (ClangTidyProvider)