Use std::reference_wrapper instead of llvm::ReferenceStorage

[Bigcheese]

lgtm.

include/llvm/Support/Error.h

 /// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
 /// error class type.
 template <class T> class LLVM_NODISCARD Expected {
   template <class T1> friend class ExpectedAsOutParameter;
   template <class OtherT> friend class Expected;
 
   static const bool isRef = std::is_reference<T>::value;
 
-  using wrap = ReferenceStorage<typename std::remove_reference<T>::type>;
+  using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
 
   using error_type = std::unique_ptr<ErrorInfoBase>;
 
 public:
   using storage_type = typename std::conditional<isRef, wrap, T>::type;
   using value_type = T;
 
 private:

include/llvm/Support/ErrorOr.h

 #include "llvm/Support/AlignOf.h"
 #include <cassert>
 #include <system_error>
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
-/// Stores a reference that can be changed.
-template <typename T>
-class ReferenceStorage {
-  T *Storage;
-
-public:
-  ReferenceStorage(T &Ref) : Storage(&Ref) {}
-
-  operator T &() const { return *Storage; }
-  T &get() const { return *Storage; }
-};
-
 /// Represents either an error or a value T.
 ///
 /// ErrorOr<T> is a pointer-like class that represents the result of an
 /// operation. The result is either an error, or a value of type T. This is
 /// designed to emulate the usage of returning a pointer where nullptr indicates
 /// failure. However instead of just knowing that the operation failed, we also
 /// have an error_code and optional user data that describes why it failed.
 ///

 ///
 /// T cannot be a rvalue reference.
 template<class T>
 class ErrorOr {
   template <class OtherT> friend class ErrorOr;
 
   static const bool isRef = std::is_reference<T>::value;
 
-  using wrap = ReferenceStorage<typename std::remove_reference<T>::type>;
+  using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
 
 public:
   using storage_type = typename std::conditional<isRef, wrap, T>::type;
 
 private:
   using reference = typename std::remove_reference<T>::type &;
   using const_reference = const typename std::remove_reference<T>::type &;
   using pointer = typename std::remove_reference<T>::type *;