[clangd] Make ProjectAwareIndex optionally sync

[kadircet]

Summary

Depends on D98029.

[kadircet]

ping

clang-tools-extra/clangd/index/ProjectAware.h

 #include "support/Threading.h"
 #include <functional>
 #include <memory>
 namespace clang {
 namespace clangd {
 
 /// A functor to create an index for an external index specification. Functor
 /// should perform any high latency operation in a separate thread through
-/// AsyncTaskRunner.
+/// AsyncTaskRunner, if set.
 using IndexFactory = std::function<std::unique_ptr<SymbolIndex>(
-    const Config::ExternalIndexSpec &, AsyncTaskRunner &)>;
+    const Config::ExternalIndexSpec &, AsyncTaskRunner *)>;
 
 /// Returns an index that answers queries using external indices. IndexFactory
-/// specifies how to generate an index from an external source.
+/// specifies how to generate an index from an external source. If \p Sync is
+/// set, index won't own any asnyc task runner.
 /// IndexFactory must be injected because this code cannot depend on the remote
 /// index client.
-std::unique_ptr<SymbolIndex> createProjectAwareIndex(IndexFactory);
+std::unique_ptr<SymbolIndex> createProjectAwareIndex(IndexFactory, bool Sync);
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/index/ProjectAware.cpp

public:
   /// Query all indexes while prioritizing the associated one (if any).
   void relations(const RelationsRequest &Req,
                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
                      Callback) const override;
 
   llvm::unique_function<IndexContents(llvm::StringRef) const>
   indexedFiles() const override;
 
-  ProjectAwareIndex(IndexFactory Gen) : Gen(std::move(Gen)) {}
+  ProjectAwareIndex(IndexFactory Gen, bool Sync) : Gen(std::move(Gen)) {
+    if (!Sync)
+      Tasks = std::make_unique<AsyncTaskRunner>();
+  }
 
 private:
   // Returns the index associated with current context, if any.
   SymbolIndex *getIndex() const;
 
   // Storage for all the external indexes.
   mutable std::mutex Mu;
   mutable llvm::DenseMap<Config::ExternalIndexSpec,
                          std::unique_ptr<SymbolIndex>>
       IndexForSpec;
-  mutable AsyncTaskRunner Tasks;
+  mutable std::unique_ptr<AsyncTaskRunner> Tasks;
 
   const IndexFactory Gen;
 };
 
 size_t ProjectAwareIndex::estimateMemoryUsage() const {
   size_t Total = 0;
   std::lock_guard<std::mutex> Lock(Mu);
   for (auto &Entry : IndexForSpec)

 SymbolIndex *ProjectAwareIndex::getIndex() const {
   const auto &C = Config::current();
   if (!C.Index.External)
     return nullptr;
   const auto &External = *C.Index.External;
   std::lock_guard<std::mutex> Lock(Mu);
   auto Entry = IndexForSpec.try_emplace(External, nullptr);
   if (Entry.second)
-    Entry.first->getSecond() = Gen(External, Tasks);
+    Entry.first->getSecond() = Gen(External, Tasks.get());
   return Entry.first->second.get();
 }
 } // namespace
 
-std::unique_ptr<SymbolIndex> createProjectAwareIndex(IndexFactory Gen) {
+std::unique_ptr<SymbolIndex> createProjectAwareIndex(IndexFactory Gen,
+                                                     bool Sync) {
   assert(Gen);
-  return std::make_unique<ProjectAwareIndex>(std::move(Gen));
+  return std::make_unique<ProjectAwareIndex>(std::move(Gen), Sync);
 }
 } // namespace clangd
 } // namespace clang

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

 #ifdef _WIN32
 const char TestScheme::TestDir[] = "C:\\clangd-test";
 #else
 const char TestScheme::TestDir[] = "/clangd-test";
 #endif
 
 std::unique_ptr<SymbolIndex>
 loadExternalIndex(const Config::ExternalIndexSpec &External,
-                  AsyncTaskRunner &Tasks) {
+                  AsyncTaskRunner *Tasks) {
   switch (External.Kind) {
   case Config::ExternalIndexSpec::Server:
     log("Associating {0} with remote index at {1}.", External.MountPoint,
         External.Location);
     return remote::getClient(External.Location, External.MountPoint);
   case Config::ExternalIndexSpec::File:
     log("Associating {0} with monolithic index at {1}.", External.MountPoint,
         External.Location);
     auto NewIndex = std::make_unique<SwapIndex>(std::make_unique<MemIndex>());
     auto IndexLoadTask = [File = External.Location,
                           PlaceHolder = NewIndex.get()] {
       if (auto Idx = loadIndex(File, /*UseDex=*/true))
         PlaceHolder->reset(std::move(Idx));
     };
-    // FIXME: The signature should contain a null-able TaskRunner istead, and
-    // the task should be scheduled accordingly.
-    if (Sync) {
-      IndexLoadTask();
-    } else {
-      Tasks.runAsync("Load-index:" + External.Location,
+    if (Tasks) {
+      Tasks->runAsync("Load-index:" + External.Location,
                       std::move(IndexLoadTask));
+    } else {
+      IndexLoadTask();
     }
     return std::move(NewIndex);
   }
   llvm_unreachable("Invalid ExternalIndexKind.");
 }
 
 class FlagsConfigProvider : public config::Provider {
 private:
if (IndexFile.empty()) {
       log("Connecting to remote index at {0}", RemoteIndexAddress);
     } else {
       elog("When enabling remote index, IndexFile should not be specified. "
            "Only one can be used at time. Remote index will ignored.");
     }
   }
 #endif
   Opts.BackgroundIndex = EnableBackgroundIndex;
-  auto PAI = createProjectAwareIndex(loadExternalIndex);
+  auto PAI = createProjectAwareIndex(loadExternalIndex, Sync);
   if (StaticIdx) {
     IdxStack.emplace_back(std::move(StaticIdx));
     IdxStack.emplace_back(
         std::make_unique<MergedIndex>(PAI.get(), IdxStack.back().get()));
     Opts.StaticIndex = IdxStack.back().get();
   } else {
     Opts.StaticIndex = PAI.get();
   }

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

 
 std::unique_ptr<SymbolIndex> createIndex() {
   SymbolSlab::Builder Builder;
   Builder.insert(symbol("1"));
   return MemIndex::build(std::move(Builder).build(), RefSlab(), RelationSlab());
 }
 
 TEST(ProjectAware, Test) {
-  IndexFactory Gen = [](const Config::ExternalIndexSpec &, AsyncTaskRunner &) {
+  IndexFactory Gen = [](const Config::ExternalIndexSpec &, AsyncTaskRunner *) {
     return createIndex();
   };
 
-  auto Idx = createProjectAwareIndex(std::move(Gen));
+  auto Idx = createProjectAwareIndex(std::move(Gen), true);
   FuzzyFindRequest Req;
   Req.Query = "1";
   Req.AnyScope = true;
 
   EXPECT_THAT(match(*Idx, Req), IsEmpty());
 
   Config C;
   C.Index.External.emplace();
   C.Index.External->Location = "test";
   WithContextValue With(Config::Key, std::move(C));
   EXPECT_THAT(match(*Idx, Req), ElementsAre("1"));
   return;
 }
 
 TEST(ProjectAware, CreatedOnce) {
   unsigned InvocationCount = 0;
-  IndexFactory Gen = [&](const Config::ExternalIndexSpec &, AsyncTaskRunner &) {
+  IndexFactory Gen = [&](const Config::ExternalIndexSpec &, AsyncTaskRunner *) {
     ++InvocationCount;
     return createIndex();
   };
 
-  auto Idx = createProjectAwareIndex(std::move(Gen));
+  auto Idx = createProjectAwareIndex(std::move(Gen), true);
   // No invocation at start.
   EXPECT_EQ(InvocationCount, 0U);
   FuzzyFindRequest Req;
   Req.Query = "1";
   Req.AnyScope = true;
 
   // Cannot invoke without proper config.
   match(*Idx, Req);