[clangd] Added a callback-based codeComplete in clangd.

Reviewers: klimek, bkramer, sammccall, krasimir

Reviewed By: sammccall

Subscribers: rwols, cfe-commits

Differential Revision: https://reviews.llvm.org/D38629

git-svn-id: https://llvm.org/svn/llvm-project/clang-tools-extra/trunk@316565 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 52 insertions, 23 deletions

diff --git a/clangd/ClangdServer.cpp b/clangd/ClangdServer.cpp
index f8a5d22d..9338cb1b 100644
--- a/clangd/ClangdServer.cpp
+++ b/clangd/ClangdServer.cpp
@@ -198,6 +198,28 @@ std::future<Tagged<std::vector<CompletionItem>>>
 ClangdServer::codeComplete(PathRef File, Position Pos,
                            llvm::Optional<StringRef> OverridenContents,
                            IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
+  using ResultType = Tagged<std::vector<CompletionItem>>;
+
+  std::promise<ResultType> ResultPromise;
+
+  auto Callback = [](std::promise<ResultType> ResultPromise,
+                     ResultType Result) -> void {
+    ResultPromise.set_value(std::move(Result));
+  };
+
+  std::future<ResultType> ResultFuture = ResultPromise.get_future();
+  codeComplete(BindWithForward(Callback, std::move(ResultPromise)), File, Pos,
+               OverridenContents, UsedFS);
+  return ResultFuture;
+}
+
+void ClangdServer::codeComplete(
+    UniqueFunction<void(Tagged<std::vector<CompletionItem>>)> Callback,
+    PathRef File, Position Pos, llvm::Optional<StringRef> OverridenContents,
+    IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS) {
+  using CallbackType =
+      UniqueFunction<void(Tagged<std::vector<CompletionItem>>)>;
+
   std::string Contents;
   if (OverridenContents) {
     Contents = *OverridenContents;
@@ -216,9 +238,6 @@ ClangdServer::codeComplete(PathRef File, Position Pos,
   std::shared_ptr<CppFile> Resources = Units.getFile(File);
   assert(Resources && "Calling completion on non-added file");
 
-  using PackagedTask =
-      std::packaged_task<Tagged<std::vector<CompletionItem>>()>;
-
   // Remember the current Preamble and use it when async task starts executing.
   // At the point when async task starts executing, we may have a different
   // Preamble in Resources. However, we assume the Preamble that we obtain here
@@ -226,26 +245,25 @@ ClangdServer::codeComplete(PathRef File, Position Pos,
   std::shared_ptr<const PreambleData> Preamble =
       Resources->getPossiblyStalePreamble();
   // A task that will be run asynchronously.
-  PackagedTask Task([=]() mutable { // 'mutable' to reassign Preamble variable.
-    if (!Preamble) {
-      // Maybe we built some preamble before processing this request.
-      Preamble = Resources->getPossiblyStalePreamble();
-    }
-    // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
-    // both the old and the new version in case only one of them matches.
-
-    std::vector<CompletionItem> Result = clangd::codeComplete(
-        File, Resources->getCompileCommand(),
-        Preamble ? &Preamble->Preamble : nullptr, Contents, Pos, TaggedFS.Value,
-        PCHs, CodeCompleteOpts, Logger);
-    return make_tagged(std::move(Result), std::move(TaggedFS.Tag));
-  });
-
-  auto Future = Task.get_future();
-  // FIXME(ibiryukov): to reduce overhead for wrapping the same callable
-  // multiple times, ClangdScheduler should return future<> itself.
-  WorkScheduler.addToFront([](PackagedTask Task) { Task(); }, std::move(Task));
-  return Future;
+  auto Task =
+      // 'mutable' to reassign Preamble variable.
+      [=](CallbackType Callback) mutable {
+        if (!Preamble) {
+          // Maybe we built some preamble before processing this request.
+          Preamble = Resources->getPossiblyStalePreamble();
+        }
+        // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
+        // both the old and the new version in case only one of them matches.
+
+        std::vector<CompletionItem> Result = clangd::codeComplete(
+            File, Resources->getCompileCommand(),
+            Preamble ? &Preamble->Preamble : nullptr, Contents, Pos,
+            TaggedFS.Value, PCHs, CodeCompleteOpts, Logger);
+
+        Callback(make_tagged(std::move(Result), std::move(TaggedFS.Tag)));
+      };
+
+  WorkScheduler.addToFront(std::move(Task), std::move(Callback));
 }
 
 Tagged<SignatureHelp>
diff --git a/clangd/ClangdServer.h b/clangd/ClangdServer.h
index 08d4569b..f70fb5c8 100644
--- a/clangd/ClangdServer.h
+++ b/clangd/ClangdServer.h
@@ -234,6 +234,9 @@ public:
   /// and AST and rebuild them from scratch.
   std::future<void> forceReparse(PathRef File);
 
+  /// DEPRECATED. Please use a callback-based version, this API is deprecated
+  /// and will soon be removed.
+  ///
   /// Run code completion for \p File at \p Pos.
   ///
   /// Request is processed asynchronously. You can use the returned future to
@@ -253,6 +256,14 @@ public:
                llvm::Optional<StringRef> OverridenContents = llvm::None,
                IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS = nullptr);
 
+  /// A version of `codeComplete` that runs \p Callback on the processing thread
+  /// when codeComplete results become available.
+  void codeComplete(
+      UniqueFunction<void(Tagged<std::vector<CompletionItem>>)> Callback,
+      PathRef File, Position Pos,
+      llvm::Optional<StringRef> OverridenContents = llvm::None,
+      IntrusiveRefCntPtr<vfs::FileSystem> *UsedFS = nullptr);
+
   /// Provide signature help for \p File at \p Pos. If \p OverridenContents is
   /// not None, they will used only for signature help, i.e. no diagnostics
   /// update will be scheduled and a draft for \p File will not be updated. If