[clangd] Add static index for the global code completion.

[hokein]

Summary

Use the YAML-format symbols (generated by the global-symbol-builder tool) to
do the global code completion.
It is experimental only , but it allows us to experience global code
completion on a relatively small project.

Tested with LLVM project.

[ioeric]

clangd/ClangdLSPServer.h

40

We are calling this global index and static index in the patch. I think we should be consistent with the naming. Generally, I think this is static index, which might be global index or, say, a set of symbols for test purpose, so I am inclined to static index.

clangd/CodeComplete.cpp

604

I would suggest also addressing this FIXME in this patch, or at least make it possible to tell from which index source a candidate comes on the client side. Simple concatenation from both indexes would make the results hard to interpret, especially when we don't have a good merging algorithm at this point.

clangd/CodeComplete.h

72

clangd client is a confusing term? Do you mean clangd library users? Also, I think this field is only set internally by clangd in this patch.

74

This depends on users, so I would drop this line.

clangd/index/MemIndex.cpp

56

s/Slab/Builder/?

Any reason not to pass in a SymbolSlab directly?

clangd/index/MemIndex.h

42

I'd make this a factory method and call it Build.

clangd/tool/ClangdMain.cpp

118

Maybe YamlSymbolFile or something similar without "global"? Yaml could potentially be used for other static indexes.

unittests/clangd/CodeCompleteTests.cpp

487

We should also have a test where results come from both static index and ast index.

[ioeric]

You have mentioned that YAML data source is experimental only in the patch summary, but we should also mention this in the code.

[ilya-biryukov]

clangd/tool/ClangdMain.cpp

121

Let's also add a mention here in the documentation that the option is experimental, will be removed in the future and users should not rely on it.

[hokein]

Address review comments.

[hokein]

Thanks for the comments.

clangd/ClangdLSPServer.h

40

+1 static index -- I forgot to rename the global index.

clangd/CodeComplete.cpp

604

The FIXME is mainly about the merging algorithm.

I still prefer to a follow-up on telling the client from which index source a completion item comes. I can foresee we might need to add an new field (like Source) in the CompleitionItem. Let's keep this patch simple at the moment.

[ioeric]

clangd/CodeComplete.cpp

604

I don't think we need additional field for this. We could manipulate the label or detail of the completion item (e.g. adding a tag), which shouldn't be too much extra work for this patch. IMO, concatenated results might easily be more confusing than useful for our testing purpose at this point, given no merging algorithm.

[hokein]

Add index source information to the completion item.

[hokein]

Update

[ioeric]

clangd/ClangdServer.h

211

Please also add comment for this.

345

... in addition to the FileIdx above?

clangd/CodeComplete.cpp

588

AFAIK, Detail is not visible in the completion item list unless you hover on an item. I'd suggest throwing a "[G]" prefix to labels of the global symbols. For completion clang::^, the list would look like:

clang::Local1
clang::Local2
[G]clang::Global1
[G]clang::Global2

WDYT?

655–656

We might not want to lose (non-index-based) AST symbols if we only have StaticIndex. Maybe only use static index augment the dynamic index?

clangd/CodeComplete.h

72

It's unclear whether this is set internally or expected to be set by users?

[hokein]

Address comments.

[hokein]

clangd/ClangdServer.h

345

Updated the comment.

clangd/CodeComplete.cpp

588

Yeah, this would make debugging easier. We could figure out a better shown way to the end users in the future.

655–656

The Opts.StaticIndex check is not need here, removed it -- the StaticIndex is set when enable-index-based-completion is on.

[ioeric]

lgtm

clangd/CodeComplete.cpp

555

Maybe IndexSourceLabel?

587

Is this blank line intended?

[hokein]

Fix remaining comments.

[sammccall]

clangd/ClangdLSPServer.h

40

is there a reason ClangdServer should own this? I can imagine this complicating life for embedders. (vs a raw pointer)

clangd/CodeComplete.cpp

555

Actually, can we give this a more generic name like DebuggingLabel?
That will make things less confusing as we store slightly different info here over time (e.g. this text will definitely change when merging happens). It also indicates that this isn't functionally important.

If you don't mind, I'd also change the value so you just pass "G" and it gets formatted into "[G] " by this function. That means we can easily format it differently (e.g. hide it from the UI actually include it in the JSON as an extension field) in a way that makes sense.

604

nit: this comment implies that we should do a two-way merge here between static/dynamic index. I don't think that's the case.
We're also going want to merge with AST based results, and probably want to do that *before* generating CompletionItems, because scoring should take signals from all sources into account.

I'd suggest reverting this function to use just one index, and calling it twice.
Then this comment about merging would live near the call site, and cover all three sources - it'd suggest the fix where we should be applying it.

[ilya-biryukov]

clangd/ClangdLSPServer.h

40

+1, we had a design where ClangdServer owns everything before and having a raw reference turned out to be much more flexible!

[hokein]

Address review comments.

[sammccall]

Ilya's suggestion to have a single index on the CodeCompleteOptions that encapsulates the merging seems reasonable to me, but not urgent.
So let's get this in as-is and we can make that change whenever.

clangd/CodeComplete.cpp

568

move this inside and only use for nontrivial case?

656

Shouldn't it already be false here?

657

do you only want to use the static index if the dynamic index is also present?
(That logic may exist at a higher level, but I'm not sure it makes sense to have it here)

I'd suggest to remove the result items empty check and the clear(), and then just put the two index runs in independent if statements

[hokein]

• make static index independent with dynamic index
• don't clear results from clang's completion engine as we also intend to merge

them into the final results eventually.

[sammccall]

Nice! LG

[hokein]

• Update comment
• Only use Sema results if the scope specifier (ns::^) is not a namespace scope specifier.

[sammccall]

clangd/CodeComplete.cpp

660

I don't think we need this - we plan to avoid overlap by splitting on current file vs other files - i'll put together a patch to make sema do what we want.
Until we've got that done, having some duplicate results is OK (this feature is experimental still).

[hokein]

Remove the temporary fix.

[hokein]

clangd/CodeComplete.cpp

660

Thanks, that makes sense. Reverted it.

clangd/ClangdLSPServer.h

 #include "ProtocolHandlers.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
 
 namespace clang {
 namespace clangd {
 
 class JSONOutput;
+class SymbolIndex;
 
 /// This class provides implementation of an LSP server, glueing the JSON
 /// dispatch and ClangdServer together.
 class ClangdLSPServer : private DiagnosticsConsumer, private ProtocolCallbacks {
 public:
   /// If \p CompileCommandsDir has a value, compile_commands.json will be
   /// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
   /// for compile_commands.json in all parent directories of each file.
   ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
                   bool StorePreamblesInMemory,
                   const clangd::CodeCompleteOptions &CCOpts,
                   llvm::Optional<StringRef> ResourceDir,
                   llvm::Optional<Path> CompileCommandsDir,
-                  bool BuildDynamicSymbolIndex);
+                  bool BuildDynamicSymbolIndex,
+                  SymbolIndex *StaticIdx = nullptr);
 
   /// Run LSP server loop, receiving input for it from \p In. \p In must be
   /// opened in binary mode. Output will be written using Out variable passed to
   /// class constructor. This method must not be executed more than once for
   /// each instance of ClangdLSPServer.
   ///
   /// \return Wether we received a 'shutdown' request before an 'exit' request
   bool run(std::istream &In);

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onDocumentHighlight(Ctx C,
   reply(C, json::ary(Highlights->Value));
 }
 
 ClangdLSPServer::ClangdLSPServer(JSONOutput &Out, unsigned AsyncThreadsCount,
                                  bool StorePreamblesInMemory,
                                  const clangd::CodeCompleteOptions &CCOpts,
                                  llvm::Optional<StringRef> ResourceDir,
                                  llvm::Optional<Path> CompileCommandsDir,
-                                 bool BuildDynamicSymbolIndex)
+                                 bool BuildDynamicSymbolIndex,
+                                 SymbolIndex *StaticIdx)
     : Out(Out), CDB(std::move(CompileCommandsDir)), CCOpts(CCOpts),
       Server(CDB, /*DiagConsumer=*/*this, FSProvider, AsyncThreadsCount,
-             StorePreamblesInMemory, BuildDynamicSymbolIndex, ResourceDir) {}
+             StorePreamblesInMemory, BuildDynamicSymbolIndex, StaticIdx,
+             ResourceDir) {}
 
 bool ClangdLSPServer::run(std::istream &In) {
   assert(!IsDone && "Run was called before");
 
   // Set up JSONRPCDispatcher.
   JSONRPCDispatcher Dispatcher([](Context Ctx, const json::Expr &Params) {
     replyError(Ctx, ErrorCode::MethodNotFound, "method not found");
   });

clangd/ClangdServer.h

public:
   /// synchronize access to shared state.
   ///
   /// \p StorePreamblesInMemory defines whether the Preambles generated by
   /// clangd are stored in-memory or on disk.
   ///
   /// If \p BuildDynamicSymbolIndex is true, ClangdServer builds a dynamic
   /// in-memory index for symbols in all opened files and uses the index to
   /// augment code completion results.
+  ///
+  /// If \p StaticIdx is set, ClangdServer uses the index for global code
+  /// completion.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
                FileSystemProvider &FSProvider, unsigned AsyncThreadsCount,
                bool StorePreamblesInMemory,
                bool BuildDynamicSymbolIndex = false,
+               SymbolIndex *StaticIdx = nullptr,
                llvm::Optional<StringRef> ResourceDir = llvm::None);
 
   /// Set the root path of the workspace.
   void setRootPath(PathRef RootPath);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
private:
   scheduleCancelRebuild(Context Ctx, std::shared_ptr<CppFile> Resources);
 
   GlobalCompilationDatabase &CDB;
   DiagnosticsConsumer &DiagConsumer;
   FileSystemProvider &FSProvider;
   DraftStore DraftMgr;
   /// If set, this manages index for symbols in opened files.
   std::unique_ptr<FileIndex> FileIdx;
+  /// If set, this provides static index for project-wide global symbols.
+  /// clangd global code completion result will come from the static index and
+  /// the `FileIdx` above.
+  /// No owned, the life time is managed by clangd embedders.
+  SymbolIndex *StaticIdx;
   CppFileCollection Units;
   std::string ResourceDir;
   // If set, this represents the workspace path.
   llvm::Optional<std::string> RootPath;
   std::shared_ptr<PCHContainerOperations> PCHs;
   bool StorePreamblesInMemory;
   /// Used to serialize diagnostic callbacks.
   /// FIXME(ibiryukov): get rid of an extra map and put all version counters

clangd/ClangdServer.cpp

for (auto &Worker : Workers)
     Worker.join();
 }
 
 ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            DiagnosticsConsumer &DiagConsumer,
                            FileSystemProvider &FSProvider,
                            unsigned AsyncThreadsCount,
                            bool StorePreamblesInMemory,
-                           bool BuildDynamicSymbolIndex,
+                           bool BuildDynamicSymbolIndex, SymbolIndex *StaticIdx,
                            llvm::Optional<StringRef> ResourceDir)
     : CDB(CDB), DiagConsumer(DiagConsumer), FSProvider(FSProvider),
       FileIdx(BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
+      StaticIdx(StaticIdx),
       // Pass a callback into `Units` to extract symbols from a newly parsed
       // file and rebuild the file index synchronously each time an AST is
       // parsed.
       // FIXME(ioeric): this can be slow and we may be able to index on less
       // critical paths.
       Units(FileIdx
                 ? [this](const Context &Ctx, PathRef Path,
                          ParsedAST *AST) { FileIdx->update(Ctx, Path, AST); }
void ClangdServer::codeComplete(
   // Preamble in Resources. However, we assume the Preamble that we obtain here
   // is reusable in completion more often.
   std::shared_ptr<const PreambleData> Preamble =
       Resources->getPossiblyStalePreamble();
   // Copy completion options for passing them to async task handler.
   auto CodeCompleteOpts = Opts;
   if (FileIdx)
     CodeCompleteOpts.Index = FileIdx.get();
+  if (StaticIdx)
+    CodeCompleteOpts.StaticIndex = StaticIdx;
   // A task that will be run asynchronously.
   auto Task =
       // 'mutable' to reassign Preamble variable.
       [=](Context Ctx, CallbackType Callback) mutable {
         if (!Preamble) {
           // Maybe we built some preamble before processing this request.
           Preamble = Resources->getPossiblyStalePreamble();
         }

clangd/CodeComplete.h

struct CodeCompleteOptions {
   size_t Limit = 0;
 
   // Populated internally by clangd, do not set.
   /// If `Index` is set, it is used to augment the code completion
   /// results.
   /// FIXME(ioeric): we might want a better way to pass the index around inside
   /// clangd.
   const SymbolIndex *Index = nullptr;
+
+  // Populated internally by clangd, do not set.
+  /// Static index for project-wide global symbols.
+  const SymbolIndex *StaticIndex = nullptr;
 };
 
 /// Get code completions at a specified \p Pos in \p FileName.
 CompletionList codeComplete(const Context &Ctx, PathRef FileName,
                             const tooling::CompileCommand &Command,
                             PrecompiledPreamble const *Preamble,
                             StringRef Contents, Position Pos,
                             IntrusiveRefCntPtr<vfs::FileSystem> VFS,
                             std::shared_ptr<PCHContainerOperations> PCHs,

clangd/CodeComplete.cpp

 #include "CodeCompletionStrings.h"
 #include "Compiler.h"
 #include "Logger.h"
 #include "index/Index.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
+#include "llvm/Support/Format.h"
 #include <queue>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 CompletionItemKind toCompletionItemKind(CXCursorKind CursorKind) {
   switch (CursorKind) {
bool invokeCodeComplete(const Context &Ctx,
   }
 
   Action.EndSourceFile();
 
   return true;
 }
 
 CompletionItem indexCompletionItem(const Symbol &Sym, llvm::StringRef Filter,
-                                   const SpecifiedScope &SSInfo) {
+                                   const SpecifiedScope &SSInfo,
+                                   llvm::StringRef DebuggingLabel = "") {
   CompletionItem Item;
   Item.kind = toCompletionItemKind(Sym.SymInfo.Kind);
+  // Add DebuggingLabel to the completion results if DebuggingLabel is not
+  // empty.
+  //
+  // For symbols from static index, there are prefix "[G]" in the
+  // results (which is used for debugging purpose).
+  // So completion list will be like:
+  //   clang::symbol_from_dynamic_index
+  //   [G]clang::symbol_from_static_index
+  //
+  // FIXME: Find out a better way to show the index source.
+  if (!DebuggingLabel.empty()) {
+    llvm::raw_string_ostream Label(Item.label);
+    Label << llvm::format("[%s]%s", DebuggingLabel.str().c_str(),
+                          Sym.Name.str().c_str());
+  } else {
     Item.label = Sym.Name;
+  }
   // FIXME(ioeric): support inserting/replacing scope qualifiers.
   Item.insertText = Sym.Name;
   // FIXME(ioeric): support snippets.
   Item.insertTextFormat = InsertTextFormat::PlainText;
   Item.filterText = Sym.Name;
 
   // FIXME(ioeric): sort symbols appropriately.
   Item.sortText = "";
 
   // FIXME(ioeric): use more symbol information (e.g. documentation, label) to
   // populate the completion item.
 
   return Item;
 }
 
 void completeWithIndex(const Context &Ctx, const SymbolIndex &Index,
                        llvm::StringRef Code, const SpecifiedScope &SSInfo,
-                       llvm::StringRef Filter, CompletionList *Items) {
+                       llvm::StringRef Filter, CompletionList *Items,
+                       llvm::StringRef DebuggingLabel = "") {
   FuzzyFindRequest Req;
   Req.Query = Filter;
   // FIXME(ioeric): add more possible scopes based on using namespaces and
   // containing namespaces.
   StringRef Scope = SSInfo.Resolved.empty() ? SSInfo.Written : SSInfo.Resolved;
   Req.Scopes = {Scope.trim(':').str()};
 
-  Items->isIncomplete = !Index.fuzzyFind(Ctx, Req, [&](const Symbol &Sym) {
-    Items->items.push_back(indexCompletionItem(Sym, Filter, SSInfo));
+  Items->isIncomplete |= !Index.fuzzyFind(Ctx, Req, [&](const Symbol &Sym) {
+    Items->items.push_back(
+        indexCompletionItem(Sym, Filter, SSInfo, DebuggingLabel));
   });
 }
 
 SpecifiedScope extraCompletionScope(Sema &S, const CXXScopeSpec &SS) {
   SpecifiedScope Info;
   auto &SM = S.getSourceManager();
   auto SpecifierRange = SS.getRange();
   Info.Written = Lexer::getSourceText(
       CharSourceRange::getCharRange(SpecifierRange), SM, clang::LangOptions());
CompletionList codeComplete(const Context &Ctx, PathRef FileName,
                             std::shared_ptr<PCHContainerOperations> PCHs,
                             CodeCompleteOptions Opts) {
   CompletionList Results;
   NameToComplete CompletedName;
   auto Consumer =
       llvm::make_unique<CompletionItemsCollector>(Opts, Results, CompletedName);
   invokeCodeComplete(Ctx, std::move(Consumer), Opts.getClangCompleteOpts(),
                      FileName, Command, Preamble, Contents, Pos, std::move(VFS),
                      std::move(PCHs));
-  if (Opts.Index && CompletedName.SSInfo) {
-    if (!Results.items.empty())
-      log(Ctx, "WARNING: Got completion results from sema for completion on "
-               "qualified ID while symbol index is provided.");
-    Results.items.clear();
+
+  // Got scope specifier (ns::f^) for code completion from sema, try to query
+  // global symbols from indexes.
+  if (CompletedName.SSInfo) {
+    // FIXME: figure out a good algorithm to merge symbols from different
+    // sources (dynamic index, static index, AST symbols from clang's completion
+    // engine).
+    if (Opts.Index)
       completeWithIndex(Ctx, *Opts.Index, Contents, *CompletedName.SSInfo,
                         CompletedName.Filter, &Results);
+    if (Opts.StaticIndex)
+      completeWithIndex(Ctx, *Opts.StaticIndex, Contents, *CompletedName.SSInfo,
+                        CompletedName.Filter, &Results, /*DebuggingLabel=*/"G");
   }
   return Results;
 }
 
 SignatureHelp signatureHelp(const Context &Ctx, PathRef FileName,
                             const tooling::CompileCommand &Command,
                             PrecompiledPreamble const *Preamble,
                             StringRef Contents, Position Pos,

clangd/index/MemIndex.h

 /// \brief This implements an index for a (relatively small) set of symbols that
 /// can be easily managed in memory.
 class MemIndex : public SymbolIndex {
 public:
   /// \brief (Re-)Build index for `Symbols`. All symbol pointers must remain
   /// accessible as long as `Symbols` is kept alive.
   void build(std::shared_ptr<std::vector<const Symbol *>> Symbols);
 
+  /// \brief Build index from a symbol slab.
+  static std::unique_ptr<SymbolIndex> build(SymbolSlab Slab);
+
   bool
   fuzzyFind(const Context &Ctx, const FuzzyFindRequest &Req,
             llvm::function_ref<void(const Symbol &)> Callback) const override;
 
 private:
   std::shared_ptr<std::vector<const Symbol *>> Symbols;
   // Index is a set of symbols that are deduplicated by symbol IDs.
   // FIXME: build smarter index structure.
   llvm::DenseMap<SymbolID, const Symbol *> Index;
   mutable std::mutex Mutex;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_MEMINDEX_H

clangd/index/MemIndex.cpp

for (const auto Pair : Index) {
           return false;
         Callback(*Sym);
       }
     }
   }
   return true;
 }
 
+std::unique_ptr<SymbolIndex> MemIndex::build(SymbolSlab Slab) {
+  struct Snapshot {
+    SymbolSlab Slab;
+    std::vector<const Symbol *> Pointers;
+  };
+  auto Snap = std::make_shared<Snapshot>();
+  Snap->Slab = std::move(Slab);
+  for (auto &Sym : Snap->Slab)
+    Snap->Pointers.push_back(&Sym);
+  auto S = std::shared_ptr<std::vector<const Symbol *>>(std::move(Snap),
+                                                        &Snap->Pointers);
+  auto MemIdx = llvm::make_unique<MemIndex>();
+  MemIdx->build(std::move(S));
+  return std::move(MemIdx);
+}
+
 } // namespace clangd
 } // namespace clang

clangd/tool/ClangdMain.cpp

 //===--- ClangdMain.cpp - clangd server loop ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 #include "Path.h"
 #include "Trace.h"
+#include "index/SymbolYAML.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iostream>
 #include <memory>
 #include <string>
 #include <thread>
 
 using namespace clang;
 using namespace clang::clangd;
 
 namespace {
 enum class PCHStorageFlag { Disk, Memory };
+
+// Build an in-memory static index for global symbols from a YAML-format file.
+// The size of global symbols should be relatively small, so that all symbols
+// can be managed in memory.
+std::unique_ptr<SymbolIndex> BuildStaticIndex(llvm::StringRef YamlSymbolFile) {
+  auto Buffer = llvm::MemoryBuffer::getFile(YamlSymbolFile);
+  if (!Buffer) {
+    llvm::errs() << "Can't open " << YamlSymbolFile << "\n";
+    return nullptr;
+  }
+  auto Slab = SymbolFromYAML(Buffer.get()->getBuffer());
+  SymbolSlab::Builder SymsBuilder;
+  for (auto Sym : Slab)
+    SymsBuilder.insert(Sym);
+
+  return MemIndex::build(std::move(SymsBuilder).build());
 }
+} // namespace
 
 static llvm::cl::opt<Path> CompileCommandsDir(
     "compile-commands-dir",
     llvm::cl::desc("Specify a path to look for compile_commands.json. If path "
                    "is invalid, clangd will look in the current directory and "
                    "parent paths of each source file."));
 
 static llvm::cl::opt<unsigned>

 
 static llvm::cl::opt<bool> EnableIndexBasedCompletion(
     "enable-index-based-completion",
     llvm::cl::desc(
         "Enable index-based global code completion (experimental). Clangd will "
         "use index built from symbols in opened files"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
+static llvm::cl::opt<Path> YamlSymbolFile(
+    "yaml-symbol-file",
+    llvm::cl::desc(
+        "YAML-format global symbol file to build the static index. Clangd will "
+        "use the static index for global code completion.\n"
+        "WARNING: This option is experimental only, and will be removed "
+        "eventually. Don't rely on it."),
+    llvm::cl::init(""), llvm::cl::Hidden);
+
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv, "clangd");
 
   if (!RunSynchronously && WorkerThreadsCount == 0) {
     llvm::errs() << "A number of worker threads cannot be 0. Did you mean to "
                     "specify -run-synchronously?";
     return 1;
   }
int main(int argc, char *argv[]) {
 
   llvm::Optional<StringRef> ResourceDirRef = None;
   if (!ResourceDir.empty())
     ResourceDirRef = ResourceDir;
 
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
 
+  std::unique_ptr<SymbolIndex> StaticIdx;
+  if (EnableIndexBasedCompletion && !YamlSymbolFile.empty())
+    StaticIdx = BuildStaticIndex(YamlSymbolFile);
   clangd::CodeCompleteOptions CCOpts;
   CCOpts.EnableSnippets = EnableSnippets;
   CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
   // Initialize and run ClangdLSPServer.
   ClangdLSPServer LSPServer(Out, WorkerThreadsCount, StorePreamblesInMemory,
                             CCOpts, ResourceDirRef, CompileCommandsDirPath,
-                            EnableIndexBasedCompletion);
+                            EnableIndexBasedCompletion, StaticIdx.get());
   constexpr int NoShutdownRequestErrorCode = 1;
   llvm::set_thread_name("clangd.main");
   return LSPServer.run(std::cin) ? 0 : NoShutdownRequestErrorCode;
 }

unittests/clangd/CodeCompleteTests.cpp

EXPECT_THAT(Results.signatures,
               ElementsAre(Sig("baz(int a, int b, int c) -> int",
                               {"int a", "int b", "int c"})));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(1, Results.activeParameter);
 }
 
 std::unique_ptr<SymbolIndex> simpleIndexFromSymbols(
     std::vector<std::pair<std::string, index::SymbolKind>> Symbols) {
-  auto I = llvm::make_unique<MemIndex>();
-  struct Snapshot {
-    SymbolSlab Slab;
-    std::vector<const Symbol *> Pointers;
-  };
-  auto Snap = std::make_shared<Snapshot>();
   SymbolSlab::Builder Slab;
   for (const auto &Pair : Symbols) {
     Symbol Sym;
     Sym.ID = SymbolID(Pair.first);
     llvm::StringRef QName = Pair.first;
     size_t Pos = QName.rfind("::");
     if (Pos == llvm::StringRef::npos) {
       Sym.Name = QName;
       Sym.Scope = "";
     } else {
       Sym.Name = QName.substr(Pos + 2);
       Sym.Scope = QName.substr(0, Pos);
     }
     Sym.SymInfo.Kind = Pair.second;
     Slab.insert(Sym);
   }
-  Snap->Slab = std::move(Slab).build();
-  for (auto &Iter : Snap->Slab)
-    Snap->Pointers.push_back(&Iter);
-  auto S = std::shared_ptr<std::vector<const Symbol *>>(std::move(Snap),
-                                                        &Snap->Pointers);
-  I->build(std::move(S));
-  return std::move(I);
+  return MemIndex::build(std::move(Slab).build());
 }
 
 TEST(CompletionTest, NoIndex) {
   clangd::CodeCompleteOptions Opts;
   Opts.Index = nullptr;
 
   auto Results = completions(R"cpp(
       namespace ns { class No {}; }
       void f() { ns::^ }
   )cpp",
                              Opts);
   EXPECT_THAT(Results.items, Has("No"));
 }
 
+TEST(CompletionTest, StaticAndDynamicIndex) {
+  clangd::CodeCompleteOptions Opts;
+  auto StaticIdx =
+      simpleIndexFromSymbols({{"ns::XYZ", index::SymbolKind::Class}});
+  Opts.StaticIndex = StaticIdx.get();
+  auto DynamicIdx =
+      simpleIndexFromSymbols({{"ns::foo", index::SymbolKind::Function}});
+  Opts.Index = DynamicIdx.get();
+
+  auto Results = completions(R"cpp(
+      void f() { ::ns::^ }
+  )cpp",
+                             Opts);
+  EXPECT_THAT(Results.items, Contains(Labeled("[G]XYZ")));
+  EXPECT_THAT(Results.items, Contains(Labeled("foo")));
+}
+
 TEST(CompletionTest, SimpleIndexBased) {
   clangd::CodeCompleteOptions Opts;
   auto I = simpleIndexFromSymbols({{"ns::XYZ", index::SymbolKind::Class},
                                    {"nx::XYZ", index::SymbolKind::Class},
                                    {"ns::foo", index::SymbolKind::Function}});
   Opts.Index = I.get();
 
   auto Results = completions(R"cpp(