[clangd] Enable extraction of system includes from custom toolchains

[kadircet]

Summary

Some custom toolchains come with their own header files and compiler
drivers. Those compiler drivers implicitly know about include search path for
those headers. This patch aims to extract that information from drivers and add
it to the command line when invoking clang frontend.

[sammccall]

Implementation looks good. I can't see a better way to solve this problem, it's just a bit unfortunate to have a sophisticated solution but not be able to turn it on by default.

I think naming is important here: it's a fairly complicated feature that (I suppose) relatively few will use, so having an unambiguous way to refer to it e.g. in docs will reduce the cost/confusion.
I suggested "QueryDriver" below, but we might be able to come up with something better offline.

clang-tools-extra/clangd/ClangdServer.h

127

not a regex

127

I think this probably wants to be a vector<string> (comma-separated on command-line)?

Clangd-level settings aren't easy to customize per-project.

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

65

Can we move the implementation out to a separate file?
It's pretty logically separate, and about as much code as everything else together.
It could also use a file-level comment describing how the scheme works, and also the reasons it's not always on (security, and not all argv0's are gcc-compatible)
(Sharing the same header seems fine)

71

I'd consider std::search for the delimiters explicitly - I think it's clearer what happens when you find one but not the other.

(And you probably want to log an error and do nothing unless you find both)

82

Is this check important? (What happens if non-existent dirs are on the include path?)

If it is, maybe we should pass in the VFS (factory?) here.

90

some explanation of what this is doing?

e.g. "Many compilers have default system includes... these are known by the driver and passed to cc1 ... gcc and compilers with compatible CLI can dump the cc1 invocation information with this syntax... we do so and parse the result."

96

nit: please don't bother with const on locals (style is debatable, but it's hardly used anywhere and adds little value unless used consistently)

96

we need to remove this file at some point

99

log messages should contain more context, e.g. "Driver flags extraction: failed to create temporary file"

108

this will crash if the lookup didn't provide a "real" type

112

should we check the driver exists before executing it? the main advantage would be that we avoid logging this as if it were an error (or we do so with a better error message)

125

I think we should log the success case too... remember this is only going to happen once per driver (or {driver, filetype}).

129

just take cmd by reference and modify it?

140

please use llvm::Regex::escape() on the chunks between *, so we're sure to be consistent

178

I think you need to subscribe to changes in the base and broadcast them to your own subscribers.
As it stands this breaks background indexing I think.
This pattern is error prone, as it's too easy to forget :-(

190

check the CommandLine isn't empty? (I know, silly...)

190

The flag values will be absolute paths (or must be, to make any security sense), so we need to make Driver absolute before checking against it (using the command's working directory). And we need to make sure the string we exec is the same as the one we check, so that needs to be absolute too.

195

regex check is part of the cacheable computation.

198

you're computing based on the filename, but caching based only on the driver.

If the filename is important, I think we should probably restructure so you get the filetype here and cache by it instead.

210

put "cache" in the name?

clang-tools-extra/clangd/GlobalCompilationDatabase.h

96

If the trusted list is empty, it seems reasonable just to return Base. Then the caller can skip the check.

96

if null base is forbidden (seems to be the intent here), just say so, don't specify what happens in that case (and probably add an assert)

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

271

I'm not sure this is the right name, because "trusted" doesn't indficate what the feature does or when you might need it. And we've mitigated most of the security risk by turning this off by default, I'm not sure we actually need a warning in the flag name.

Maybe -query-driver=?

(commenting here because it's the main user-visible documentation, but I think we should use consistent names throughout, e.g. QueryDriverGlob).

273

nit: drop "tells clangd to", it's implied

273

from gcc-compatible drivers

274

I think it's more useful to give an example (/usr/bin/**/clang-*) than try to describe glob syntax.

276

is there something useful we should set this to by default? like /usr/bin/gcc,/usr/bin/g++?

Or is the assumption that the standard/system compilers will never have weird information to extract?

[ilya-biryukov]

Could you give more context on what the custom toolchains are?
One feasible alternative is to move this detection to clang's driver (where the rest of include path detection lives), why won't that work?

[kadircet]

• Address comments

[kadircet]

In D62804#1533710, @ilya-biryukov wrote:

Could you give more context on what the custom toolchains are?
One feasible alternative is to move this detection to clang's driver (where the rest of include path detection lives), why won't that work?

Moving this logic into clang's driver should also work there is nothing specific to clangd. This patch just fetches those headers and adds them to clang invocation command line with a "-isystem" in front of them.
But we execute an arbitrary binary to fetch system includes coming from the custom toolchain drivers. Therefore we decided to rather keep it contained in clangd hidden behind a flag during offline discussions.

For example a gcc cross compiling to arm comes with its own system includes and has some mechanisms to discover that implicitly, without requiring any "-I" flags.
Hence when used with clangd, we make use of system includes instead of the target's include library. This patch aims to solve that issue, tools like cquery also handles that problem in a similar way.

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

82

Existence of the directory doesn't really matter, I've put this as a debug measure, in case we get a "non-path"(malformed) entry.
But I suppose we can already see this in the "Updating a.cc with command ...." log.

So removing it.

90

I've aleady mentioned this in file comment, do you think it is necessary to mention that in here as well?

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

276

I believe this is not an issue with default gcc/g++ since we never heard such complaints. I would rather leave the default empty until we observe some wide usage, due to security concerns

[ilya-biryukov]

In D62804#1538155, @kadircet wrote:

For example a gcc cross compiling to arm comes with its own system includes and has some mechanisms to discover that implicitly, without requiring any "-I" flags.
Hence when used with clangd, we make use of system includes instead of the target's include library. This patch aims to solve that issue, tools like cquery also handles that problem in a similar way.

That's exactly what driver is about. The approach is slightly different, though. Instead of executing a binary, one has to mimic the toolchain search logic of a particular toolchain by hand.
In addition to includes, it also handles adding the corresponding -D flags and anything else that the cross-compile toolchain does. Is this toolchain not currently supported by the driver? Is adding it so much work that we would choose to workaround like this instead?

[kadircet]

• Fix off-by-one bug and improve lit test

[kadircet]

In D62804#1538202, @ilya-biryukov wrote:

In D62804#1538155, @kadircet wrote:

For example a gcc cross compiling to arm comes with its own system includes and has some mechanisms to discover that implicitly, without requiring any "-I" flags.
Hence when used with clangd, we make use of system includes instead of the target's include library. This patch aims to solve that issue, tools like cquery also handles that problem in a similar way.

That's exactly what driver is about. The approach is slightly different, though. Instead of executing a binary, one has to mimic the toolchain search logic of a particular toolchain by hand.
In addition to includes, it also handles adding the corresponding -D flags and anything else that the cross-compile toolchain does. Is this toolchain not currently supported by the driver? Is adding it so much work that we would choose to workaround like this instead?

As discussed offline, this is also a possible way to go. but looks like it requires making sure every toolchain has correct logic to deduce include paths which is more work and could become outdated, in addition to that it is also possible to introduce breakages due to new search logic. whereas this solution fixes the problem for all target.
So we decided to keep it clangd specific.

[kadircet]

ping

[sammccall]

clang-tools-extra/clangd/ClangdLSPServer.cpp

343

if statement is not needed I think, as you return base if empty

clang-tools-extra/clangd/SystemIncludeExtractor.cpp

1 ↗

(On Diff #204243)

This name is a little limiting (e.g. if we want to pull more info from the driver).

Not a big problem, but especially if you anticipate pulling out more properties, query-driver or similar might be clearer.

66 ↗

(On Diff #204243)

also log output here?

91 ↗

(On Diff #204243)

This isn't an error - probably vlog, *maybe* log

143 ↗

(On Diff #204243)

also include extracted includes - the info for this weird setup is important to preserve in the logs I think

152 ↗

(On Diff #204243)

Technically this doesn't work if the command is clang --driver-mode=cl ... - you'll be able to query the info from clang using the default gcc-compatible syntax, but the actual command-line won't support the -isystem flag.

Not worth fixing I think but a comment?

254 ↗

(On Diff #204243)

docs says it returns base if globs are empty?

clang-tools-extra/clangd/test/system-include-extractor.test

2

Wow, I'm impressed you managed to test this :-)

Test needs quite a lot of comments to explain what it's doing though, I think.

[kadircet]

• Rename SystemIncludeExtractor to QueryDriverDatabase
• Address comments

clang-tools-extra/clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "Diagnostics.h"
+#include "GlobalCompilationDatabase.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "Trace.h"
 #include "URI.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
if (Params.rootUri && *Params.rootUri)
     ClangdServerOpts.WorkspaceRoot = Params.rootUri->file();
   else if (Params.rootPath && !Params.rootPath->empty())
     ClangdServerOpts.WorkspaceRoot = *Params.rootPath;
   if (Server)
     return Reply(llvm::make_error<LSPError>("server already initialized",
                                             ErrorCode::InvalidRequest));
   if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
     CompileCommandsDir = Dir;
-  if (UseDirBasedCDB)
+  if (UseDirBasedCDB) {
     BaseCDB = llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(
         CompileCommandsDir);
+    if (!ClangdServerOpts.TrustedCompilerDriverGlob.empty())
+      BaseCDB = getSystemIncludeExtractorDatabase(
+          ClangdServerOpts.TrustedCompilerDriverGlob, std::move(BaseCDB));
+  }
   CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
               ClangdServerOpts.ResourceDir);
   Server.emplace(*CDB, FSProvider, static_cast<DiagnosticsConsumer &>(*this),
                  ClangdServerOpts);
   applyConfiguration(Params.initializationOptions.ConfigSettings);
 
   CCOpts.EnableSnippets = Params.capabilities.CompletionSnippets;
   DiagOpts.EmbedFixesInDiagnostics = Params.capabilities.DiagnosticFixes;

clang-tools-extra/clangd/ClangdServer.h

struct Options {
     /// obtain the standard resource directory.
     llvm::Optional<std::string> ResourceDir = llvm::None;
 
     /// Time to wait after a new file version before computing diagnostics.
     std::chrono::steady_clock::duration UpdateDebounce =
         std::chrono::milliseconds(500);
 
     bool SuggestMissingIncludes = false;
+
+    /// If set clangd will execute compiler drivers matching the following regex
+    /// to fetch system include path.
+    std::string TrustedCompilerDriverGlob;
   };
   // Sensible default options for use in tests.
   // Features like indexing must be enabled if desired.
   static Options optsForTest();
 
   /// Creates a new ClangdServer instance.
   ///
   /// ClangdServer uses \p CDB to obtain compilation arguments for parsing. Note

clang-tools-extra/clangd/GlobalCompilationDatabase.h

private:
   mutable llvm::StringMap<std::unique_ptr<clang::tooling::CompilationDatabase>>
       CompilationDatabases;
 
   /// Used for command argument pointing to folder where compile_commands.json
   /// is located.
   llvm::Optional<Path> CompileCommandsDir;
 };
 
+/// Extracts system include search path from trusted drivers and adds them to
+/// the compile flags.
+/// Returns nullptr when \p TrustedCompilerDriverGlob is empty or \p Base is
+/// nullptr.
+std::unique_ptr<GlobalCompilationDatabase> getSystemIncludeExtractorDatabase(
+    llvm::StringRef TrustedCompilerDriverGlob,
+    std::unique_ptr<GlobalCompilationDatabase> Base);
+
 /// Wraps another compilation database, and supports overriding the commands
 /// using an in-memory mapping.
 class OverlayCDB : public GlobalCompilationDatabase {
 public:
   // Base may be null, in which case no entries are inherited.
   // FallbackFlags are added to the fallback compile command.
   OverlayCDB(const GlobalCompilationDatabase *Base,
              std::vector<std::string> FallbackFlags = {},

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

 //===--- GlobalCompilationDatabase.cpp ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "GlobalCompilationDatabase.h"
 #include "Logger.h"
+#include "Path.h"
+#include "Trace.h"
+#include "clang/Driver/Types.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 void adjustArguments(tooling::CompileCommand &Cmd,
                      llvm::StringRef ResourceDir) {
   tooling::ArgumentsAdjuster ArgsAdjuster = tooling::combineAdjusters(
if (!ResourceDir.empty())
     Cmd.CommandLine.push_back(("-resource-dir=" + ResourceDir).str());
 }
 
 std::string getStandardResourceDir() {
   static int Dummy; // Just an address in this process.
   return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
 }
 
+std::vector<std::string> parseDriverOutput(llvm::StringRef Output) {
+  std::vector<std::string> SystemIncludes;
+  constexpr char const *SIS = "#include <...> search starts here:";
+  constexpr char const *SIE = "End of search list.";
+  llvm::SmallVector<llvm::StringRef, 8> Lines;
+  Output.split(Lines, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
+  bool FoundStart = false;
+  for (llvm::StringRef Line : Lines) {
+    if (Line == SIS) {
+      FoundStart = true;
+      continue;
+    }
+    if (Line == SIE)
+      break;
+    if (!FoundStart)
+      continue;
+
+    if (!llvm::sys::fs::exists(Line))
+      elog("Parsed non-existing system include: {0}", Line);
+    SystemIncludes.push_back(Line.str());
+    vlog("Added: {0}", Line);
+  }
+  return SystemIncludes;
+}
+
+std::vector<std::string> extractSystemIncludes(PathRef Driver, PathRef File) {
+  trace::Span Tracer("Extract system includes");
+  SPAN_ATTACH(Tracer, "driver", Driver);
+  SPAN_ATTACH(Tracer, "file", File);
+
+  llvm::SmallString<128> OutputPath;
+  const auto EC = llvm::sys::fs::createTemporaryFile("system-includes",
+                                                     "clangd", OutputPath);
+  if (EC) {
+    elog("Couldn't create temporary file: {0}", EC.message());
+    return {};
+  }
+  const llvm::Optional<llvm::StringRef> Redirects[] = {
+      {""}, llvm::StringRef(OutputPath), {""}};
+
+  const llvm::StringRef Ext = llvm::sys::path::extension(File).trim('.');
+  const auto Type = driver::types::lookupTypeForExtension(Ext);
+  // Should we also preserve flags like "-sysroot", "-nostdinc" ?
+  const llvm::StringRef Args[] = {"-E", "-x", driver::types::getTypeName(Type),
+                                  "-", "-v"};
+
+  const int RC =
+      llvm::sys::ExecuteAndWait(Driver, Args, /*Env=*/llvm::None, Redirects);
+  if (RC) {
+    elog("Execution failed with return code: {0}", llvm::to_string(RC));
+    return {};
+  }
+
+  auto BufOrError = llvm::MemoryBuffer::getFile(OutputPath);
+  if (!BufOrError) {
+    elog("Failed to read {0}: {1}", OutputPath,
+         BufOrError.getError().message());
+    return {};
+  }
+
+  return parseDriverOutput(BufOrError->get()->getBuffer());
+}
+
+tooling::CompileCommand
+addSystemIncludes(tooling::CompileCommand Cmd,
+                  llvm::ArrayRef<std::string> SystemIncludes) {
+  for (llvm::StringRef Include : SystemIncludes) {
+    Cmd.CommandLine.push_back("-isystem");
+    Cmd.CommandLine.push_back(Include.str());
+  }
+  return Cmd;
+}
+
+/// Converts a glob containing only ** or * into a regex.
+llvm::Regex convertGlobToRegex(llvm::StringRef Glob) {
+  const llvm::StringRef MetaChars("()^$|*+?.[]\\{}");
+  std::string RegText;
+  llvm::raw_string_ostream RegStream(RegText);
+  RegStream << '^';
+  for (size_t I = 0, E = Glob.size(); I < E; ++I) {
+    if (Glob[I] == '*') {
+      if (I + 1 < E && Glob[I + 1] == '*') {
+        // Double star, accept any sequence.
+        RegStream << ".*";
+        // Also skip the second star.
+        ++I;
+      } else {
+        // Single star, accept any sequence without a slash.
+        RegStream << "[^/]*";
+      }
+    } else if (MetaChars.find(Glob[I]) != MetaChars.npos)
+      RegStream << '\\' << Glob[I];
+    else
+      RegStream << Glob[I];
+  }
+  RegStream << '$';
+  RegStream.flush();
+
+  llvm::Regex Result(RegText);
+  assert(Result.isValid(RegText) && "Glob to regex conversion failed");
+  return Result;
+}
+
+/// Extracts system includes from a trusted driver by parsing the output of
+/// include search path and appends them to the commands coming from underlying
+/// compilation database.
+class SystemIncludeExtractorDatabase : public GlobalCompilationDatabase {
+public:
+  SystemIncludeExtractorDatabase(
+      llvm::StringRef TrustedCompilerDriverGlob,
+      std::unique_ptr<GlobalCompilationDatabase> Base)
+      : TrustedCompilerDriverRegex(
+            convertGlobToRegex(TrustedCompilerDriverGlob)),
+        Base(std::move(Base)) {
+    assert(this->Base && "Base cannot be null!");
+    assert(!TrustedCompilerDriverGlob.empty() &&
+           "TrustedCompilerDriverGlob cannot be empty!");
+  }
+
+  llvm::Optional<tooling::CompileCommand>
+  getCompileCommand(PathRef File, ProjectInfo *PI = nullptr) const override {
+    auto Cmd = Base->getCompileCommand(File, PI);
+    if (!Cmd)
+      return llvm::None;
+
+    llvm::StringRef Driver = Cmd->CommandLine.front();
+
+    llvm::ArrayRef<std::string> SystemIncludes;
+    {
+      std::lock_guard<std::mutex> Lock(Mu);
+      if (!TrustedCompilerDriverRegex.match(Driver))
+        return Cmd;
+
+      auto It = DriverToIncludes.try_emplace(Driver);
+      if (It.second)
+        It.first->second = extractSystemIncludes(Driver, File);
+      SystemIncludes = It.first->second;
+    }
+
+    return addSystemIncludes(*Cmd, SystemIncludes);
+  }
+
+private:
+  mutable std::mutex Mu;
+  // Caches includes extracted from a driver.
+  mutable llvm::StringMap<std::vector<std::string>> DriverToIncludes;
+  mutable llvm::Regex TrustedCompilerDriverRegex;
+
+  std::unique_ptr<GlobalCompilationDatabase> Base;
+};
+
 } // namespace
 
 static std::string getFallbackClangPath() {
   static int Dummy;
   std::string ClangdExecutable =
       llvm::sys::fs::getMainExecutable("clangd", (void *)&Dummy);
   SmallString<128> ClangPath;
   ClangPath = llvm::sys::path::parent_path(ClangdExecutable);
void OverlayCDB::setCompileCommand(
     if (Cmd)
       Commands[File] = std::move(*Cmd);
     else
       Commands.erase(File);
   }
   OnCommandChanged.broadcast({File});
 }
 
+std::unique_ptr<GlobalCompilationDatabase> getSystemIncludeExtractorDatabase(
+    llvm::StringRef TrustedCompilerDriverGlob,
+    std::unique_ptr<GlobalCompilationDatabase> Base) {
+  return llvm::make_unique<SystemIncludeExtractorDatabase>(
+      TrustedCompilerDriverGlob, std::move(Base));
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/test/system-include-extractor.test

+# RUN: rm -rf %t.dir && mkdir -p %t.dir
+
+# RUN: echo '#!/bin/bash' >> %t.dir/my_driver.sh
+# RUN: echo 'echo line to ignore' >> %t.dir/my_driver.sh
+# RUN: echo 'echo \#include \<...\> search starts here:' >> %t.dir/my_driver.sh
+# RUN: echo 'echo %t.dir/my/dir/' >> %t.dir/my_driver.sh
+# RUN: echo 'echo End of search list.' >> %t.dir/my_driver.sh
+# RUN: chmod +x %t.dir/my_driver.sh
+
+# RUN: mkdir -p %t.dir/my/dir
+# RUN: touch %t.dir/my/dir/a.h
+
+# RUN: echo '[{"directory": "%/t.dir", "command": "%/t.dir/my_driver.sh the-file.cpp", "file": "the-file.cpp"}]' > %t.dir/compile_commands.json
+
+# RUN: sed -e "s|INPUT_DIR|%/t.dir|g" %s > %t.test.1
+# On Windows, we need the URI in didOpen to look like "uri":"file:///C:/..."
+# (with the extra slash in the front), so we add it here.
+# RUN: sed -e "s|file://\([A-Z]\):/|file:///\1:/|g" %t.test.1 > %t.test
+
+# RUN: clangd -lit-test -trusted-compiler-driver-glob="**/*.sh" < %t.test | FileCheck -strict-whitespace %t.test
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{}}
+---
+{
+  "jsonrpc":"2.0",
+  "method":"textDocument/didOpen",
+  "params": {
+    "textDocument": {
+      "uri": "file://INPUT_DIR/the-file.cpp",
+      "languageId":"cpp",
+      "version":1,
+      "text":"#include <a.h>"
+    }
+  }
+}
+# CHECK:   "method": "textDocument/publishDiagnostics",
+# CHECK-NEXT:   "params": {
+# CHECK-NEXT:     "diagnostics": [],
+---
+{"jsonrpc":"2.0","id":10000,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}

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

CodeCompletionParse(
                                     "Block until the parser can be used"),
                          clEnumValN(CodeCompleteOptions::ParseIfReady, "auto",
                                     "Use text-based completion if the parser "
                                     "is not ready"),
                          clEnumValN(CodeCompleteOptions::NeverParse, "never",
                                     "Always used text-based completion")),
         llvm::cl::init(CodeCompleteOptions().RunParser), llvm::cl::Hidden);
 
+static llvm::cl::opt<std::string> TrustedCompilerDriverGlob(
+    "trusted-compiler-driver-glob",
+    llvm::cl::desc("Tells clangd to extract system includes from drivers "
+                   "maching the glob. Only accepts ** for sequence match and * "
+                   "for non-sequence match."),
+    llvm::cl::init(""));
+
 namespace {
 
 /// \brief Supports a test URI scheme with relaxed constraints for lit tests.
 /// The path in a test URI will be combined with a platform-specific fake
 /// directory to form an absolute path. For example, test:///a.cpp is resolved
 /// C:\clangd-test\a.cpp on Windows and /clangd-test/a.cpp on Unix.
 class TestScheme : public URIScheme {
 public:
#endif
   Opts.GetClangTidyOptions = [&](llvm::vfs::FileSystem &,
                                  llvm::StringRef File) {
     // This function must be thread-safe and tidy option providers are not.
     std::lock_guard<std::mutex> Lock(ClangTidyOptMu);
     // FIXME: use the FS provided to the function.
     return ClangTidyOptProvider->getOptions(File);
   };
   Opts.SuggestMissingIncludes = SuggestMissingIncludes;
+  Opts.TrustedCompilerDriverGlob = TrustedCompilerDriverGlob;
   llvm::Optional<OffsetEncoding> OffsetEncodingFromFlag;
   if (ForceOffsetEncoding != OffsetEncoding::UnsupportedEncoding)
     OffsetEncodingFromFlag = ForceOffsetEncoding;
   ClangdLSPServer LSPServer(
       *TransportLayer, FSProvider, CCOpts, CompileCommandsDirPath,
       /*UseDirBasedCDB=*/CompileArgsFrom == FilesystemCompileArgs,
       OffsetEncodingFromFlag, Opts);
   llvm::set_thread_name("clangd.main");
   return LSPServer.run() ? 0
                          : static_cast<int>(ErrorResultCode::NoShutdownRequest);
 }