[clangd] Added move-only function helpers.

[ilya-biryukov]

Summary

They are now used in ClangdScheduler instead of deferred std::async
computations.
The results of std::async are much less effective and do not provide
a good abstraction for similar purposes, i.e. for storing additional callbacks
to clangd async tasks. The actual callback API will follow a bit later.

[ilya-biryukov]

• Fix to ForwardBinder.
• Add UniqueFunction(nullptr) constructor.
• Added missing STL headers to Function.h

[ilya-biryukov]

• Use proper types (Args&&) when forwarding arguments.

[sammccall]

clangd/Function.h

9 ↗

(On Diff #118184)

Maybe add a file comment "provides analogues to std::function that supports move semantics"?

36 ↗

(On Diff #118184)

Do you want this constructor to be explicit?

If not, I think you should be able to simplify the callsites in ClangdServer.h

77 ↗

(On Diff #118184)

nit: just 'moved'? std::move is just a cast...

117 ↗

(On Diff #118184)

I find these "first arg" APIs a bit awkward, and can lead to writing confusing APIs for easier binding. Not sure there's a good alternative, though.

121 ↗

(On Diff #118184)

nit: can -> must?

[ilya-biryukov]

Addressed review comments.

• Added a file comment.
• Simplified callsites of UniqueFunction in ClangdServer.h
• Properly forward UniqueFunction's constructor argument.
• Updates to comments.

clangd/Function.h

36 ↗

(On Diff #118184)

Thanks for spotting this.
I think implicit works fine here. std::function also has implicit constructors. Simplified the callsites.

117 ↗

(On Diff #118184)

Yeah. Works just like std::bind, though. And I would be very happy to remove that particular function altogether when we'll be able to use lambda initializer in LLVM codebase.

[chapuni]

Excuse me, Ubuntu 14.04's g++-4.8.4 doesn't compile it. :(
Any idea?

In file included from clang-tools-extra/clangd/ClangdServer.h:23:0,
                 from clang-tools-extra/clangd/ClangdServer.cpp:10:
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23, std::promise<void>, std::future<void> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: no match for call to ‘(clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23, std::promise<void>, std::future<void> >) ()’
     Ret Call(Args... As) override { return Func(std::forward<Args>(As)...); }
                                                                          ^
clang-tools-extra/clangd/Function.h:82:45: note: candidate is:
 template <class Func, class... Args> struct ForwardBinder {
                                             ^
clang-tools-extra/clangd/Function.h:108:8: note: template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23; Args = {std::promise<void>, std::future<void>}]
   auto operator()(RestArgs &&... Rest)
        ^
clang-tools-extra/clangd/Function.h:108:8: note:   template argument deduction/substitution failed:
clang-tools-extra/clangd/Function.h: In substitution of ‘template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23; Args = {std::promise<void>, std::future<void>}] [with RestArgs = {}]’:
clang-tools-extra/clangd/Function.h:68:74:   required from ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23, std::promise<void>, std::future<void> >; Ret = void; Args = {}]’
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:110:59: error: cannot call member function ‘decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::CallImpl(llvm::integer_sequence<long unsigned int, Indexes ...>, RestArgs&& ...) [with long unsigned int ...Indexes = {0ul, 1ul}; RestArgs = {}; Func = clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23; Args = {std::promise<void>, std::future<void>}; decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) = void]’ without object
                            std::forward<RestArgs>(Rest)...)) {
                                                           ^
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleCancelRebuild(std::shared_ptr<clang::clangd::CppFile>)::__lambda23, std::promise<void>, std::future<void> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: return-statement with a value, in function returning 'void' [-fpermissive]
     Ret Call(Args... As) override { return Func(std::forward<Args>(As)...); }
                                                                          ^
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22, std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: no match for call to ‘(clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22, std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void> >) ()’
clang-tools-extra/clangd/Function.h:82:45: note: candidate is:
 template <class Func, class... Args> struct ForwardBinder {
                                             ^
clang-tools-extra/clangd/Function.h:108:8: note: template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22; Args = {std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void>}]
   auto operator()(RestArgs &&... Rest)
        ^
clang-tools-extra/clangd/Function.h:108:8: note:   template argument deduction/substitution failed:
clang-tools-extra/clangd/Function.h: In substitution of ‘template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22; Args = {std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void>}] [with RestArgs = {}]’:
clang-tools-extra/clangd/Function.h:68:74:   required from ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22, std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void> >; Ret = void; Args = {}]’
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:110:59: error: cannot call member function ‘decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::CallImpl(llvm::integer_sequence<long unsigned int, Indexes ...>, RestArgs&& ...) [with long unsigned int ...Indexes = {0ul, 1ul}; RestArgs = {}; Func = clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22; Args = {std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void>}; decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) = void]’ without object
                            std::forward<RestArgs>(Rest)...)) {
                                                           ^
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::scheduleReparseAndDiags(clang::clangd::PathRef, clang::clangd::VersionedDraft, std::shared_ptr<clang::clangd::CppFile>, clang::clangd::Tagged<llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> >)::__lambda22, std::future<llvm::Optional<std::vector<clang::clangd::DiagWithFixIts, std::allocator<clang::clangd::DiagWithFixIts> > > >, std::promise<void> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: return-statement with a value, in function returning 'void' [-fpermissive]
     Ret Call(Args... As) override { return Func(std::forward<Args>(As)...); }
                                                                          ^
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17, std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: no match for call to ‘(clang::clangd::ForwardBinder<clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17, std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()> >) ()’
clang-tools-extra/clangd/Function.h:82:45: note: candidate is:
 template <class Func, class... Args> struct ForwardBinder {
                                             ^
clang-tools-extra/clangd/Function.h:108:8: note: template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17; Args = {std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()>}]
   auto operator()(RestArgs &&... Rest)
        ^
clang-tools-extra/clangd/Function.h:108:8: note:   template argument deduction/substitution failed:
clang-tools-extra/clangd/Function.h: In substitution of ‘template<class ... RestArgs> decltype (CallImpl(llvm::index_sequence_for<Iters ...>(), (forward<RestArgs>)(clang::clangd::ForwardBinder::operator()::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::operator()(RestArgs&& ...) [with RestArgs = {RestArgs ...}; Func = clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17; Args = {std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()>}] [with RestArgs = {}]’:
clang-tools-extra/clangd/Function.h:68:74:   required from ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17, std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()> >; Ret = void; Args = {}]’
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:110:59: error: cannot call member function ‘decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) clang::clangd::ForwardBinder<Func, Args>::CallImpl(llvm::integer_sequence<long unsigned int, Indexes ...>, RestArgs&& ...) [with long unsigned int ...Indexes = {0ul}; RestArgs = {}; Func = clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17; Args = {std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()>}; decltype (get<0>(this->.FuncWithArguments)((forward<Args>)((get<Indexes + 1>)(this->.FuncWithArguments))..., (forward<RestArgs>)(clang::clangd::ForwardBinder::CallImpl::Rest)...)) = void]’ without object
                            std::forward<RestArgs>(Rest)...)) {
                                                           ^
clang-tools-extra/clangd/Function.h: In instantiation of ‘Ret clang::clangd::UniqueFunction<Ret(Args ...)>::FunctionCallImpl<Callable>::Call(Args ...) [with Callable = clang::clangd::ForwardBinder<clang::clangd::ClangdServer::codeComplete(clang::clangd::PathRef, clang::clangd::Position, llvm::Optional<llvm::StringRef>, llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem>*)::__lambda17, std::packaged_task<clang::clangd::Tagged<std::vector<clang::clangd::CompletionItem, std::allocator<clang::clangd::CompletionItem> > >()> >; Ret = void; Args = {}]’:
clang-tools-extra/clangd/ClangdServer.cpp:484:1:   required from here
clang-tools-extra/clangd/Function.h:68:74: error: return-statement with a value, in function returning 'void' [-fpermissive]
     Ret Call(Args... As) override { return Func(std::forward<Args>(As)...); }
                                                                          ^

[ilya-biryukov]

In D38627#892773, @chapuni wrote:

Excuse me, Ubuntu 14.04's g++-4.8.4 doesn't compile it. :(
Any idea?

Sorry about that. Fixed in rL315284.
clang and gcc (at least version 4.8) behave differently here, so I didn't catch it before submitting.

clang-tools-extra/trunk/clangd/ClangdServer.h

 #include "GlobalCompilationDatabase.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "ClangdUnit.h"
+#include "Function.h"
 #include "Protocol.h"
 
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <type_traits>
public:
   void addToFront(Func &&F, Args &&... As) {
     if (RunSynchronously) {
       std::forward<Func>(F)(std::forward<Args>(As)...);
       return;
     }
 
     {
       std::lock_guard<std::mutex> Lock(Mutex);
-      RequestQueue.push_front(std::async(std::launch::deferred,
-                                         std::forward<Func>(F),
-                                         std::forward<Args>(As)...));
+      RequestQueue.push_front(
+          BindWithForward(std::forward<Func>(F), std::forward<Args>(As)...));
     }
     RequestCV.notify_one();
   }
 
   /// Add a new request to run function \p F with args \p As to the end of the
   /// queue. The request will be run on a separate thread.
   template <class Func, class... Args> void addToEnd(Func &&F, Args &&... As) {
     if (RunSynchronously) {
       std::forward<Func>(F)(std::forward<Args>(As)...);
       return;
     }
 
     {
       std::lock_guard<std::mutex> Lock(Mutex);
-      RequestQueue.push_back(std::async(std::launch::deferred,
-                                        std::forward<Func>(F),
-                                        std::forward<Args>(As)...));
+      RequestQueue.push_back(
+          BindWithForward(std::forward<Func>(F), std::forward<Args>(As)...));
     }
     RequestCV.notify_one();
   }
 
 private:
   bool RunSynchronously;
   std::mutex Mutex;
   /// We run some tasks on separate threads(parsing, CppFile cleanup).
   /// These threads looks into RequestQueue to find requests to handle and
   /// terminate when Done is set to true.
   std::vector<std::thread> Workers;
   /// Setting Done to true will make the worker threads terminate.
   bool Done = false;
   /// A queue of requests. Elements of this vector are async computations (i.e.
   /// results of calling std::async(std::launch::deferred, ...)).
-  std::deque<std::future<void>> RequestQueue;
+  std::deque<UniqueFunction<void()>> RequestQueue;
   /// Condition variable to wake up worker threads.
   std::condition_variable RequestCV;
 };
 
 /// Provides API to manage ASTs for a collection of C++ files and request
 /// various language features.
 /// Currently supports async diagnostics, code completion, formatting and goto
 /// definition.

clang-tools-extra/trunk/clangd/ClangdServer.cpp

if (RunSynchronously) {
     // Don't start the worker thread if we're running synchronously
     return;
   }
 
   Workers.reserve(AsyncThreadsCount);
   for (unsigned I = 0; I < AsyncThreadsCount; ++I) {
     Workers.push_back(std::thread([this]() {
       while (true) {
-        std::future<void> Request;
+        UniqueFunction<void()> Request;
 
         // Pick request from the queue
         {
           std::unique_lock<std::mutex> Lock(Mutex);
           // Wait for more requests.
           RequestCV.wait(Lock,
                          [this] { return !RequestQueue.empty() || Done; });
           if (Done)
             return;
 
           assert(!RequestQueue.empty() && "RequestQueue was empty");
 
           // We process requests starting from the front of the queue. Users of
           // ClangdScheduler have a way to prioritise their requests by putting
           // them to the either side of the queue (using either addToEnd or
           // addToFront).
           Request = std::move(RequestQueue.front());
           RequestQueue.pop_front();
         } // unlock Mutex
 
-        Request.get();
+        Request();
       }
     }));
   }
 }
 
 ClangdScheduler::~ClangdScheduler() {
   if (RunSynchronously)
     return; // no worker thread is running in that case

clang-tools-extra/trunk/clangd/Function.h

+//===--- Function.h - Utility callable wrappers  -----------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides an analogue to std::function that supports move semantics.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace clang {
+namespace clangd {
+
+/// A move-only type-erasing function wrapper. Similar to `std::function`, but
+/// allows to store move-only callables.
+template <class> class UniqueFunction;
+
+template <class Ret, class... Args> class UniqueFunction<Ret(Args...)> {
+public:
+  UniqueFunction() = default;
+  UniqueFunction(std::nullptr_t) : UniqueFunction(){};
+
+  UniqueFunction(UniqueFunction const &) = delete;
+  UniqueFunction &operator=(UniqueFunction const &) = delete;
+
+  UniqueFunction(UniqueFunction &&) noexcept = default;
+  UniqueFunction &operator=(UniqueFunction &&) noexcept = default;
+
+  template <class Callable>
+  UniqueFunction(Callable &&Func)
+      : CallablePtr(llvm::make_unique<
+                    FunctionCallImpl<typename std::decay<Callable>::type>>(
+            std::forward<Callable>(Func))) {}
+
+  operator bool() { return CallablePtr; }
+
+  Ret operator()(Args... As) {
+    assert(CallablePtr);
+    CallablePtr->Call(std::forward<Args>(As)...);
+  }
+
+private:
+  class FunctionCallBase {
+  public:
+    virtual ~FunctionCallBase() = default;
+    virtual Ret Call(Args... As) = 0;
+  };
+
+  template <class Callable>
+  class FunctionCallImpl final : public FunctionCallBase {
+    static_assert(
+        std::is_same<Callable, typename std::decay<Callable>::type>::value,
+        "FunctionCallImpl must be instanstiated with std::decay'ed types");
+
+  public:
+    FunctionCallImpl(Callable Func) : Func(std::move(Func)) {}
+
+    Ret Call(Args... As) override { return Func(std::forward<Args>(As)...); }
+
+  private:
+    Callable Func;
+  };
+
+  std::unique_ptr<FunctionCallBase> CallablePtr;
+};
+
+/// Stores a callable object (Func) and arguments (Args) and allows to call the
+/// callable with provided arguments later using `operator ()`. The arguments
+/// are std::forward'ed into the callable in the body of `operator()`. Therefore
+/// `operator()` can only be called once, as some of the arguments could be
+/// std::move'ed into the callable on first call.
+template <class Func, class... Args> struct ForwardBinder {
+  using Tuple = std::tuple<typename std::decay<Func>::type,
+                           typename std::decay<Args>::type...>;
+  Tuple FuncWithArguments;
+#ifndef NDEBUG
+  bool WasCalled = false;
+#endif
+
+public:
+  ForwardBinder(Tuple FuncWithArguments)
+      : FuncWithArguments(std::move(FuncWithArguments)) {}
+
+private:
+  template <std::size_t... Indexes, class... RestArgs>
+  auto CallImpl(llvm::integer_sequence<std::size_t, Indexes...> Seq,
+                RestArgs &&... Rest)
+      -> decltype(std::get<0>(this->FuncWithArguments)(
+          std::forward<Args>(std::get<Indexes + 1>(this->FuncWithArguments))...,
+          std::forward<RestArgs>(Rest)...)) {
+    return std::get<0>(this->FuncWithArguments)(
+        std::forward<Args>(std::get<Indexes + 1>(this->FuncWithArguments))...,
+        std::forward<RestArgs>(Rest)...);
+  }
+
+public:
+  template <class... RestArgs>
+  auto operator()(RestArgs &&... Rest)
+      -> decltype(CallImpl(llvm::index_sequence_for<Args...>(),
+                           std::forward<RestArgs>(Rest)...)) {
+
+#ifndef NDEBUG
+    assert(!WasCalled && "Can only call result of BindWithForward once.");
+    WasCalled = true;
+#endif
+    return CallImpl(llvm::index_sequence_for<Args...>(),
+                    std::forward<RestArgs>(Rest)...);
+  }
+};
+
+/// Creates an object that stores a callable (\p F) and first arguments to the
+/// callable (\p As) and allows to call \p F with \Args at a later point.
+/// Similar to std::bind, but also works with move-only \p F and \p As.
+///
+/// The returned object must be called no more than once, as \p As are
+/// std::forwarded'ed (therefore can be moved) into \p F during the call.
+template <class Func, class... Args>
+ForwardBinder<Func, Args...> BindWithForward(Func F, Args &&... As) {
+  return ForwardBinder<Func, Args...>(
+      std::make_tuple(std::forward<Func>(F), std::forward<Args>(As)...));
+}
+
+} // namespace clangd
+} // namespace clang
+
+#endif