From 112f364f0109059f10735766dfdac911ad5b7ab5 Mon Sep 17 00:00:00 2001
From: Russell Yanofsky <russ@yanofsky.org>
Date: Mon, 9 Mar 2020 13:51:45 -0400
Subject: [PATCH] Unify ReadFieldNew / ReadFieldUpdate

Replace with ReadField wrapper and CustomReadField hook to be consistent with
BuildField / CustomBuildField. This

- Makes it more straightforward pass custom types with symmetric
  CustomReadField / CustomBuildField overloads

- Simplifies debugging and overload resolution, removing hacks that allowed
  ReadFieldNew calls to forward to ReadFieldUpdate calls and vice versa

- Enables more flexibility and efficiency within CustomReadField
  implementations allowing emplacing or updating in the same function based on
  which is simpler or more efficient. Removes a lot of std::enable_if overload
  hacks

- Should allow clientInvoke to use RVO and construct return values in place
  instead of copying or moving. This will allow more types to be for supported
  as IPC return values even if they don't support default construction,
  copying, or moving.

- Improves separation of concerns, avoids need for ReadField callers to know
  whether callee will emplace or update, avoids need for emplace ReadDest
  object to have hardcoded support for map, vector, optional, shared_ptr,
  reference_wrapper types, so they now are implemented the same as any other
  custom type.
---
 include/mp/proxy-types.h | 486 +++++++++++++++++++--------------------
 include/mp/util.h        |   6 +-
 2 files changed, 238 insertions(+), 254 deletions(-)

diff --git a/include/mp/proxy-types.h b/include/mp/proxy-types.h
index 255b702d..e29753e0 100644
--- a/include/mp/proxy-types.h
+++ b/include/mp/proxy-types.h
@@ -175,257 +175,292 @@ auto PassField(TypeList<>, ServerContext& server_context, const Fn& fn, const Ar
         kj::mv(future.promise));
 }
 
-template <typename Value>
-class Emplace
+template <typename LocalType, typename EmplaceFn>
+struct ReadDestEmplace
 {
-    Value& m_value;
+    ReadDestEmplace(TypeList<LocalType>, EmplaceFn&& emplace_fn) : m_emplace_fn(emplace_fn) {}
 
-    template <typename T, typename... Params>
-    static T& call(std::optional<T>& value, Params&&... params)
+    template <typename... Args>
+    auto& construct(Args&&... args)
     {
-        value.emplace(std::forward<Params>(params)...);
-        return *value;
+        return m_emplace_fn(std::forward<Args>(args)...);
     }
 
-    template <typename T, typename... Params>
-    static T& call(std::vector<T>& value, Params&&... params)
+    template <typename UpdateFn>
+    void update(UpdateFn&& update_fn)
     {
-        value.emplace_back(std::forward<Params>(params)...);
-        return value.back();
+        update(std::forward<UpdateFn>(update_fn), Priority<1>());
     }
 
-    template <typename T, typename... Params>
-    static const T& call(std::set<T>& value, Params&&... params)
+    template <typename UpdateFn,
+        typename Enable =
+            std::enable_if_t<!std::is_const_v<std::remove_reference_t<std::invoke_result_t<EmplaceFn>>>, UpdateFn>>
+    void update(UpdateFn&& update_fn, Priority<1>)
     {
-        return *value.emplace(std::forward<Params>(params)...).first;
+        update_fn(construct());
     }
 
-    template <typename K, typename V, typename... Params>
-    static std::pair<const K, V>& call(std::map<K, V>& value, Params&&... params)
+    template <typename UpdateFn>
+    void update(UpdateFn&& update_fn, Priority<0>)
     {
-        return *value.emplace(std::forward<Params>(params)...).first;
+        std::remove_cv_t<LocalType> temp;
+        update_fn(temp);
+        construct(std::move(temp));
     }
 
-    template <typename T, typename... Params>
-    static T& call(std::shared_ptr<T>& value, Params&&... params)
+    EmplaceFn& m_emplace_fn;
+};
+
+template <typename Value>
+struct ReadDestValue
+{
+    ReadDestValue(Value& value) : m_value(value) {}
+
+    template <typename UpdateFn>
+    void update(UpdateFn&& update_fn)
     {
-        value = std::make_shared<T>(std::forward<Params>(params)...);
-        return *value;
+        update_fn(m_value);
     }
 
-    template <typename T, typename... Params>
-    static T& call(std::reference_wrapper<T>& value, Params&&... params)
+    template <typename... Args>
+    Value& construct(Args&&... args)
     {
-        value.get().~T();
-        new (&value.get()) T(std::forward<Params>(params)...);
-        return value.get();
+        m_value.~Value();
+        new (&m_value) Value(std::forward<Args>(args)...);
+        return m_value;
     }
 
-public:
-    Emplace(Value& value) : m_value(value) {}
-
-    // Needs to be declared after m_value for compiler to understand declaration.
-    template <typename... Params>
-    auto operator()(Params&&... params) -> AUTO_RETURN(Emplace::call(this->m_value, std::forward<Params>(params)...))
+    Value& m_value;
 };
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::optional<LocalType>>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::optional<LocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    DestValue&& value)
-{
-    if (!input.has()) {
-        value.reset();
-        return;
-    }
-    if (value) {
-        ReadFieldUpdate(TypeList<LocalType>(), invoke_context, input, *value);
-    } else {
-        ReadField(TypeList<LocalType>(), invoke_context, input, Emplace<DestValue>(value));
-    }
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        if (!input.has()) {
+            value.reset();
+        } else if (value) {
+            ReadField(TypeList<LocalType>(), invoke_context, input, ReadDestValue(*value));
+        } else {
+            ReadField(TypeList<LocalType>(), invoke_context, input,
+                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
+                    value.emplace(std::forward<decltype(args)>(args)...);
+                    return *value;
+                }));
+        }
+    });
 }
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::shared_ptr<LocalType>>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::shared_ptr<LocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    DestValue&& value)
-{
-    if (!input.has()) {
-        value.reset();
-        return;
-    }
-    if (value) {
-        ReadFieldUpdate(TypeList<LocalType>(), invoke_context, input, *value);
-    } else {
-        ReadField(TypeList<LocalType>(), invoke_context, input, Emplace<DestValue>(value));
-    }
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        if (!input.has()) {
+            value.reset();
+        } else if (value) {
+            ReadField(TypeList<LocalType>(), invoke_context, input, ReadDestValue(*value));
+        } else {
+            ReadField(TypeList<LocalType>(), invoke_context, input,
+                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
+                    value = std::make_shared<LocalType>(std::forward<decltype(args)>(args)...);
+                    return *value;
+                }));
+        }
+    });
 }
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<LocalType*>, InvokeContext& invoke_context, Input&& input, DestValue&& value)
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<LocalType*>,
+    InvokeContext& invoke_context,
+    Input&& input,
+    ReadDest&& read_dest)
 {
-    if (value) {
-        ReadFieldUpdate(TypeList<LocalType>(), invoke_context, std::forward<Input>(input), *value);
-    }
+    return read_dest.update([&](auto& value) {
+        if (value) {
+            ReadField(TypeList<LocalType>(), invoke_context, std::forward<Input>(input), ReadDestValue(*value));
+        }
+    });
 }
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::shared_ptr<const LocalType>>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::shared_ptr<const LocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    DestValue&& value)
+    ReadDest&& read_dest)
 {
-    if (!input.has()) {
-        value.reset();
-        return;
-    }
-    ReadField(TypeList<LocalType>(), invoke_context, std::forward<Input>(input), Emplace<DestValue>(value));
+    return read_dest.update([&](auto& value) {
+        if (!input.has()) {
+            value.reset();
+            return;
+        }
+        ReadField(TypeList<LocalType>(), invoke_context, std::forward<Input>(input),
+            ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
+                value = std::make_shared<LocalType>(std::forward<decltype(args)>(args)...);
+                return *value;
+            }));
+    });
 }
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::vector<LocalType>>, InvokeContext& invoke_context, Input&& input, DestValue&& value)
-{
-    auto data = input.get();
-    value.clear();
-    value.reserve(data.size());
-    for (auto item : data) {
-        ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item), Emplace<DestValue>(value));
-    }
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::vector<LocalType>>,
+    InvokeContext& invoke_context,
+    Input&& input,
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        auto data = input.get();
+        value.clear();
+        value.reserve(data.size());
+        for (auto item : data) {
+            ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item),
+                ReadDestEmplace(TypeList<LocalType>(), [&](auto&&... args) -> auto& {
+                    value.emplace_back(std::forward<decltype(args)>(args)...);
+                    return value.back();
+                }));
+        }
+    });
 }
 
-template <typename LocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::set<LocalType>>, InvokeContext& invoke_context, Input&& input, DestValue&& value)
-{
-    auto data = input.get();
-    value.clear();
-    for (auto item : data) {
-        ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item), Emplace<DestValue>(value));
-    }
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::set<LocalType>>,
+    InvokeContext& invoke_context,
+    Input&& input,
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        auto data = input.get();
+        value.clear();
+        for (auto item : data) {
+            ReadField(TypeList<LocalType>(), invoke_context, Make<ValueField>(item),
+                ReadDestEmplace(TypeList<const LocalType>(), [&](auto&&... args) -> auto& {
+                    return *value.emplace(std::forward<decltype(args)>(args)...).first;
+                }));
+        }
+    });
 }
 
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename DestValue>
-void ReadFieldUpdate(TypeList<std::map<KeyLocalType, ValueLocalType>>,
+template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::map<KeyLocalType, ValueLocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    DestValue&& value)
-{
-    auto data = input.get();
-    value.clear();
-    for (auto item : data) {
-        ReadField(TypeList<std::pair<KeyLocalType, ValueLocalType>>(), invoke_context, Make<ValueField>(item),
-            Emplace<DestValue>(value));
-    }
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        auto data = input.get();
+        value.clear();
+        for (auto item : data) {
+            ReadField(TypeList<std::pair<const KeyLocalType, ValueLocalType>>(), invoke_context,
+                Make<ValueField>(item),
+                ReadDestEmplace(
+                    TypeList<std::pair<const KeyLocalType, ValueLocalType>>(), [&](auto&&... args) -> auto& {
+                        return *value.emplace(std::forward<decltype(args)>(args)...).first;
+                    }));
+        }
+    });
 }
 
-// Emplace function that when called with tuple of key constructor arguments
-// reads value from pair and calls piecewise construct.
-template <typename ValueLocalType, typename Input, typename Emplace>
-struct PairValueEmplace
-{
-    InvokeContext& m_context;
-    Input& m_input;
-    Emplace& m_emplace;
-    template <typename KeyTuple>
-
-    // FIXME Should really return reference to emplaced key object.
-    void operator()(KeyTuple&& key_tuple)
-    {
-        const auto& pair = m_input.get();
-        using ValueAccessor = typename ProxyStruct<typename Decay<decltype(pair)>::Reads>::ValueAccessor;
-        ReadField(TypeList<ValueLocalType>(), m_context, Make<StructField, ValueAccessor>(pair),
-            BindTuple(Make<ComposeFn>(GetFn<1>(), Bind(m_emplace, std::piecewise_construct, key_tuple))));
-    }
-};
-
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<std::pair<KeyLocalType, ValueLocalType>>,
+template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::pair<KeyLocalType, ValueLocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace)
+    ReadDest&& read_dest)
 {
-    /* This could be simplified a lot with c++14 generic lambdas. All it is doing is:
-    ReadField(TypeList<KeyLocalType>(), invoke_context, Make<ValueField>(input.get().getKey()), [&](auto&&... key_args)
-    { ReadField(TypeList<ValueLocalType>(), invoke_context, Make<ValueField>(input.get().getValue()), [&](auto&&...
-    value_args)
-    {
-            emplace(std::piecewise_construct, std::forward_as_tuple(key_args...),
-    std::forward_as_tuple(value_args...));
-        })
-    });
-    */
     const auto& pair = input.get();
     using KeyAccessor = typename ProxyStruct<typename Decay<decltype(pair)>::Reads>::KeyAccessor;
-    ReadField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, KeyAccessor>(pair),
-        BindTuple(PairValueEmplace<ValueLocalType, Input, Emplace>{invoke_context, input, emplace}));
-}
+    using ValueAccessor = typename ProxyStruct<typename Decay<decltype(pair)>::Reads>::ValueAccessor;
 
-template <typename KeyLocalType, typename ValueLocalType, typename Input, typename Tuple>
-void ReadFieldUpdate(TypeList<std::tuple<KeyLocalType, ValueLocalType>>,
+    ReadField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, KeyAccessor>(pair),
+        ReadDestEmplace(TypeList<KeyLocalType>(), [&](auto&&... key_args) -> auto& {
+            KeyLocalType* key = nullptr;
+            ReadField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, ValueAccessor>(pair),
+                ReadDestEmplace(TypeList<ValueLocalType>(), [&](auto&&... value_args) -> auto& {
+                    auto& ret = read_dest.construct(std::piecewise_construct, std::forward_as_tuple(key_args...),
+                        std::forward_as_tuple(value_args...));
+                    key = &ret.first;
+                    return ret.second;
+                }));
+            return *key;
+        }));
+}
+
+template <typename KeyLocalType, typename ValueLocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::tuple<KeyLocalType, ValueLocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    Tuple&& tuple)
-{
-    const auto& pair = input.get();
-    using Struct = ProxyStruct<typename Decay<decltype(pair)>::Reads>;
-    ReadFieldUpdate(TypeList<KeyLocalType>(), invoke_context, Make<StructField, typename Struct::KeyAccessor>(pair),
-        std::get<0>(tuple));
-    ReadFieldUpdate(TypeList<ValueLocalType>(), invoke_context,
-        Make<StructField, typename Struct::ValueAccessor>(pair), std::get<1>(tuple));
+    ReadDest&& read_dest)
+{
+    return read_dest.update([&](auto& value) {
+        const auto& pair = input.get();
+        using Struct = ProxyStruct<typename Decay<decltype(pair)>::Reads>;
+        ReadField(TypeList<KeyLocalType>(), invoke_context, Make<StructField, typename Struct::KeyAccessor>(pair),
+            ReadDestValue(std::get<0>(value)));
+        ReadField(TypeList<ValueLocalType>(), invoke_context, Make<StructField, typename Struct::ValueAccessor>(pair),
+            ReadDestValue(std::get<1>(value)));
+    });
 }
 
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<LocalType>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<LocalType>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace,
+    ReadDest&& read_dest,
     typename std::enable_if<std::is_enum<LocalType>::value>::type* enable = 0)
 {
-    emplace(static_cast<LocalType>(input.get()));
+    return read_dest.construct(static_cast<LocalType>(input.get()));
 }
 
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<LocalType>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<LocalType>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace,
+    ReadDest&& read_dest,
     typename std::enable_if<std::is_integral<LocalType>::value>::type* enable = 0)
 {
     auto value = input.get();
     if (value < std::numeric_limits<LocalType>::min() || value > std::numeric_limits<LocalType>::max()) {
         throw std::range_error("out of bound int received");
     }
-    emplace(static_cast<LocalType>(value));
+    return read_dest.construct(static_cast<LocalType>(value));
 }
 
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<LocalType>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<LocalType>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace,
+    ReadDest&& read_dest,
     typename std::enable_if<std::is_floating_point<LocalType>::value>::type* enable = 0)
 {
     auto value = input.get();
     static_assert(std::is_same<LocalType, decltype(value)>::value, "floating point type mismatch");
-    emplace(value);
+    return read_dest.construct(value);
 }
 
-template <typename Input, typename Emplace>
-void ReadFieldNew(TypeList<std::string>, InvokeContext& invoke_context, Input&& input, Emplace&& emplace)
+template <typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::string>,
+    InvokeContext& invoke_context,
+    Input&& input,
+    ReadDest&& read_dest)
 {
     auto data = input.get();
-    emplace(CharCast(data.begin()), data.size());
+    return read_dest.construct(CharCast(data.begin()), data.size());
 }
 
-template <typename Input, size_t size>
-void ReadFieldUpdate(TypeList<unsigned char*>,
+template <size_t size, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<unsigned char[size]>,
     InvokeContext& invoke_context,
     Input&& input,
-    unsigned char (&value)[size])
+    ReadDest&& read_dest)
 {
-    auto data = input.get();
-    memcpy(value, data.begin(), size);
+    return read_dest.update([&](auto& value) {
+        auto data = input.get();
+        memcpy(value, data.begin(), size);
+    });
 }
 
 template <typename Interface, typename Impl>
@@ -441,17 +476,19 @@ std::unique_ptr<Impl> CustomMakeProxyClient(InvokeContext& context, typename Int
     return MakeProxyClient<Interface, Impl>(context, kj::mv(client));
 }
 
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<std::unique_ptr<LocalType>>,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::unique_ptr<LocalType>>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace,
+    ReadDest&& read_dest,
     typename Decay<decltype(input.get())>::Calls* enable = nullptr)
 {
     using Interface = typename Decay<decltype(input.get())>::Calls;
     if (input.has()) {
-        emplace(CustomMakeProxyClient<Interface, LocalType>(invoke_context, std::move(input.get())));
+        return read_dest.construct(
+            CustomMakeProxyClient<Interface, LocalType>(invoke_context, std::move(input.get())));
     }
+    return read_dest.construct();
 }
 
 // ProxyCallFn class is needed because c++11 doesn't support auto lambda parameters.
@@ -466,34 +503,21 @@ struct ProxyCallFn
     auto operator()(CallParams&&... params) -> AUTO_RETURN(this->m_proxy->call(std::forward<CallParams>(params)...))
 };
 
-template <typename FnR, typename... FnParams, typename Input, typename Emplace>
-void ReadFieldNew(TypeList<std::function<FnR(FnParams...)>>,
+template <typename FnR, typename... FnParams, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<std::function<FnR(FnParams...)>>,
     InvokeContext& invoke_context,
     Input&& input,
-    Emplace&& emplace)
+    ReadDest&& read_dest)
 {
     if (input.has()) {
         using Interface = typename Decay<decltype(input.get())>::Calls;
         auto client = std::make_shared<ProxyClient<Interface>>(
             input.get(), &invoke_context.connection, /* destroy_connection= */ false);
-        emplace(ProxyCallFn<decltype(client)>{std::move(client)});
+        return read_dest.construct(ProxyCallFn<decltype(client)>{std::move(client)});
     }
+    return read_dest.construct();
 };
 
-template <typename LocalType, typename Input, typename Value>
-void ReadFieldUpdate(TypeList<LocalType>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    Value&& value,
-    decltype(ReadFieldNew(TypeList<Decay<LocalType>>(),
-        invoke_context,
-        std::forward<Input>(input),
-        std::declval<Emplace<decltype(std::ref(value))>>()))* enable = nullptr)
-{
-    auto ref = std::ref(value);
-    ReadFieldNew(TypeList<Decay<LocalType>>(), invoke_context, input, Emplace<decltype(ref)>(ref));
-}
-
 template <size_t index, typename LocalType, typename Input, typename Value>
 void ReadOne(TypeList<LocalType> param,
     InvokeContext& invoke_context,
@@ -506,8 +530,8 @@ void ReadOne(TypeList<LocalType> param,
     using Accessor = typename std::tuple_element<index, typename ProxyStruct<Struct>::Accessors>::type;
     const auto& struc = input.get();
     auto&& field_value = value.*ProxyType<LocalType>::get(Index());
-    ReadFieldUpdate(
-        TypeList<Decay<decltype(field_value)>>(), invoke_context, Make<StructField, Accessor>(struc), field_value);
+    ReadField(TypeList<RemoveCvRef<decltype(field_value)>>(), invoke_context, Make<StructField, Accessor>(struc),
+        ReadDestValue(field_value));
     ReadOne<index + 1>(param, invoke_context, input, value);
 }
 
@@ -520,66 +544,27 @@ void ReadOne(TypeList<LocalType> param,
 {
 }
 
-template <typename LocalType, typename Input, typename Value>
-void ReadFieldUpdate(TypeList<LocalType> param,
+template <typename LocalType, typename Input, typename ReadDest>
+decltype(auto) CustomReadField(TypeList<LocalType> param,
     InvokeContext& invoke_context,
     Input&& input,
-    Value&& value,
+    ReadDest&& read_dest,
     typename ProxyType<LocalType>::Struct* enable = nullptr)
 {
-    ReadOne<0>(param, invoke_context, input, value);
+    return read_dest.update([&](auto& value) { ReadOne<0>(param, invoke_context, input, value); });
 }
 
-// ReadField calling Emplace when ReadFieldNew is available.
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldImpl(TypeList<LocalType>,
-    Priority<2>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    Emplace&& emplace,
-    decltype(
-        ReadFieldNew(TypeList<Decay<LocalType>>(), invoke_context, input, std::forward<Emplace>(emplace)))* enable =
-        nullptr)
-{
-    ReadFieldNew(TypeList<Decay<LocalType>>(), invoke_context, input, std::forward<Emplace>(emplace));
-}
-
-// ReadField calling Emplace when ReadFieldNew is not available, and emplace creates non-const object.
-// Call emplace first to create empty value, then ReadFieldUpdate into the new object.
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldImpl(TypeList<LocalType>,
-    Priority<1>,
-    InvokeContext& invoke_context,
-    Input&& input,
-    Emplace&& emplace,
-    typename std::enable_if<!std::is_void<decltype(emplace())>::value &&
-                            !std::is_const<typename std::remove_reference<decltype(emplace())>::type>::value>::type*
-        enable = nullptr)
+template <typename... LocalTypes, typename... Args>
+void ReadField(TypeList<LocalTypes...>, Args&&... args)
 {
-    auto&& ref = emplace();
-    ReadFieldUpdate(TypeList<Decay<LocalType>>(), invoke_context, input, ref);
-}
-
-// ReadField calling Emplace when ReadFieldNew is not available, and emplace creates const object.
-// Initialize temporary with ReadFieldUpdate then std::move into emplace.
-template <typename LocalType, typename Input, typename Emplace>
-void ReadFieldImpl(TypeList<LocalType>, Priority<0>, InvokeContext& invoke_context, Input&& input, Emplace&& emplace)
-{
-    Decay<LocalType> temp;
-    ReadFieldUpdate(TypeList<Decay<LocalType>>(), invoke_context, input, temp);
-    emplace(std::move(temp));
-}
-
-template <typename LocalTypes, typename Input, typename... Values>
-void ReadField(LocalTypes, InvokeContext& invoke_context, Input&& input, Values&&... values)
-{
-    ReadFieldImpl(LocalTypes(), Priority<2>(), invoke_context, input, std::forward<Values>(values)...);
+    CustomReadField(TypeList<RemoveCvRef<LocalTypes>...>(), std::forward<Args>(args)...);
 }
 
 template <typename LocalType, typename Input>
 void ThrowField(TypeList<LocalType>, InvokeContext& invoke_context, Input&& input)
 {
-    ReadField(TypeList<LocalType>(), invoke_context, input, ThrowFn<LocalType>());
+    ReadField(
+        TypeList<LocalType>(), invoke_context, input, ReadDestEmplace(TypeList<LocalType>(), ThrowFn<LocalType>()));
 }
 
 //! Special case for generic std::exception. It's an abstract type so it can't
@@ -970,7 +955,7 @@ void PassField(TypeList<LocalType*>, ServerContext& server_context, const Fn& fn
     Decay<LocalType> param;
 
     MaybeReadField(std::integral_constant<bool, Accessor::in>(), TypeList<LocalType>(), invoke_context, input,
-        Emplace<decltype(param)>(param));
+        ReadDestValue(param));
 
     fn.invoke(server_context, std::forward<Args>(args)..., &param);
 
@@ -1014,15 +999,6 @@ template <typename... Args>
 void MaybeReadField(std::false_type, Args&&...)
 {
 }
-template <typename... Args>
-void MaybeReadFieldUpdate(std::true_type, Args&&... args)
-{
-    ReadFieldUpdate(std::forward<Args>(args)...);
-}
-template <typename... Args>
-void MaybeReadFieldUpdate(std::false_type, Args&&...)
-{
-}
 
 template <typename LocalType, typename Value, typename Output>
 void MaybeSetWant(TypeList<LocalType*>, Priority<1>, Value&& value, Output&& output)
@@ -1041,10 +1017,14 @@ template <typename Accessor, typename LocalType, typename ServerContext, typenam
 void DefaultPassField(TypeList<LocalType>, ServerContext& server_context, Fn&& fn, Args&&... args)
 {
     InvokeContext& invoke_context = server_context;
-    std::optional<Decay<LocalType>> param;
+    using ArgType = RemoveCvRef<LocalType>;
+    std::optional<ArgType> param;
     const auto& params = server_context.call_context.getParams();
-    MaybeReadField(std::integral_constant<bool, Accessor::in>(), TypeList<LocalType>(), invoke_context,
-        Make<StructField, Accessor>(params), Emplace<decltype(param)>(param));
+    MaybeReadField(std::integral_constant<bool, Accessor::in>(), TypeList<ArgType>(), invoke_context,
+        Make<StructField, Accessor>(params), ReadDestEmplace(TypeList<ArgType>(), [&](auto&&... args) -> auto& {
+            param.emplace(std::forward<decltype(args)>(args)...);
+            return *param;
+        }));
     if (!param) param.emplace();
     fn.invoke(server_context, std::forward<Args>(args)..., static_cast<LocalType&&>(*param));
     auto&& results = server_context.call_context.getResults();
@@ -1072,7 +1052,7 @@ void CustomBuildField(TypeList<>,
 }
 
 template <typename Input>
-void ReadFieldUpdate(TypeList<>,
+decltype(auto) CustomReadField(TypeList<>,
     InvokeContext& invoke_context,
     Input&& input,
     typename std::enable_if<std::is_same<decltype(input.get()), ThreadMap::Client>::value>::type* enable = nullptr)
@@ -1086,7 +1066,7 @@ auto PassField(TypeList<>, ServerContext& server_context, const Fn& fn, Args&&..
 {
     const auto& params = server_context.call_context.getParams();
     const auto& input = Make<StructField, Accessor>(params);
-    ReadFieldUpdate(TypeList<>(), server_context, input);
+    ReadField(TypeList<>(), server_context, input);
     fn.invoke(server_context, std::forward<Args>(args)...);
     auto&& results = server_context.call_context.getResults();
     BuildField(TypeList<>(), server_context, Make<StructField, Accessor>(results));
@@ -1204,8 +1184,8 @@ struct ClientParam
         auto callRead(ClientInvokeContext& invoke_context, Results& results, TypeList<Params...>, Values&&... values)
             -> typename std::enable_if<I == sizeof...(Types)>::type
         {
-            MaybeReadFieldUpdate(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(),
-                invoke_context, Make<StructField, Accessor>(results), std::forward<Values>(values)...);
+            MaybeReadField(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(), invoke_context,
+                Make<StructField, Accessor>(results), ReadDestValue(values)...);
         }
 
         ReadResults(ClientParam* client_param) : m_client_param(client_param) {}
diff --git a/include/mp/util.h b/include/mp/util.h
index 2f781c49..174cd50a 100644
--- a/include/mp/util.h
+++ b/include/mp/util.h
@@ -203,7 +203,7 @@ template <typename Exception>
 struct ThrowFn
 {
     template <typename... Params>
-    void operator()(Params&&... params)
+    Exception& operator()(Params&&... params)
     {
         throw Exception(std::forward<Params>(params)...);
     }
@@ -238,6 +238,10 @@ struct Split<index, TypeList<Type, _Second...>, TypeList<_First...>, false>
 template <typename Callable>
 using ResultOf = decltype(std::declval<Callable>()());
 
+//! Substitutue for std::remove_cvref_t
+template <typename T>
+using RemoveCvRef = std::remove_cv_t<std::remove_reference_t<T>>;
+
 //! Type helper abbreviating std::decay.
 template <typename T>
 using Decay = typename std::decay<T>::type;