[CAS] Workaround the issue of MSVC needing default-constructible types for \c std::promise/future.

(cherry picked from commit b12f59b)

Author: akyrtzi

clang/lib/Frontend/CompileJobCacheResult.cpp

@@ -37,8 +37,7 @@ Error CompileJobCacheResult::forEachOutput(
 Error CompileJobCacheResult::forEachLoadedOutput(
     llvm::function_ref<Error(Output, std::optional<ObjectProxy>)> Callback) {
   // Kick-off materialization for all outputs concurrently.
-  SmallVector<std::future<Expected<std::optional<ObjectProxy>>>, 4>
-      FutureOutputs;
+  SmallVector<std::future<AsyncProxyValue>, 4> FutureOutputs;
   size_t Count = getNumOutputs();
   for (size_t I = 0; I < Count; ++I) {
     ObjectRef Ref = getOutputObject(I);
@@ -49,7 +48,7 @@ Error CompileJobCacheResult::forEachLoadedOutput(
   std::optional<Error> OccurredError;
   SmallVector<std::optional<ObjectProxy>, 4> Outputs;
   for (auto &FutureOutput : FutureOutputs) {
-    auto Obj = FutureOutput.get();
+    auto Obj = FutureOutput.get().take();
     if (!Obj) {
       if (!OccurredError)
         OccurredError = Obj.takeError();

llvm/include/llvm/CAS/ObjectStore.h

@@ -26,8 +26,8 @@ template <typename T> class unique_function;
 
 namespace cas {
 
+struct AsyncProxyValue;
 class ObjectStore;
-
 class ObjectProxy;
 
 /// Content-addressable storage for objects.
@@ -251,8 +251,7 @@ class ObjectStore {
   Expected<std::optional<ObjectProxy>> getProxyIfExists(ObjectRef Ref);
 
   /// Asynchronous version of \c getProxyIfExists.
-  std::future<Expected<std::optional<ObjectProxy>>>
-  getProxyAsync(ObjectRef Ref);
+  std::future<AsyncProxyValue> getProxyAsync(ObjectRef Ref);
 
   /// Read the data from \p Data into \p OS.
   uint64_t readData(ObjectHandle Node, raw_ostream &OS, uint64_t Offset = 0,
@@ -348,6 +347,20 @@ class ObjectProxy {
   ObjectHandle H;
 };
 
+/// This is used to workaround the issue of MSVC needing default-constructible
+/// types for \c std::promise/future.
+struct AsyncProxyValue {
+  Expected<std::optional<ObjectProxy>> take() { return std::move(Value); }
+
+  AsyncProxyValue() : Value(std::nullopt) {}
+  AsyncProxyValue(Error &&E) : Value(std::move(E)) {}
+  AsyncProxyValue(ObjectProxy V) : Value(std::move(V)) {}
+  AsyncProxyValue(std::nullopt_t) : Value(std::nullopt) {}
+
+private:
+  Expected<std::optional<ObjectProxy>> Value;
+};
+
 std::unique_ptr<ObjectStore> createInMemoryCAS();
 
 /// \returns true if \c LLVM_ENABLE_ONDISK_CAS configuration was enabled.

llvm/lib/CAS/ObjectStore.cpp

@@ -117,9 +117,8 @@ ObjectStore::getProxyIfExists(ObjectRef Ref) {
   return ObjectProxy::load(*this, Ref, *H);
 }
 
-std::future<Expected<std::optional<ObjectProxy>>>
-ObjectStore::getProxyAsync(ObjectRef Ref) {
-  std::promise<Expected<std::optional<ObjectProxy>>> Promise;
+std::future<AsyncProxyValue> ObjectStore::getProxyAsync(ObjectRef Ref) {
+  std::promise<AsyncProxyValue> Promise;
   auto Future = Promise.get_future();
   // FIXME: there is potential for use-after-free for the 'this' pointer.
   // Either we should always allocate shared pointers for \c ObjectStore objects