From 144ce4a0ce3d602e73333e71d2c533d7f0947062 Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Sat, 15 Mar 2025 22:18:56 +0800
Subject: [PATCH] Align behavior of rvalue reference

---
 proxy.h                          | 88 ++++++++++++++------------------
 tests/proxy_creation_tests.cpp   |  1 +
 tests/proxy_invocation_tests.cpp |  2 +
 tests/proxy_rtti_tests.cpp       |  3 +-
 4 files changed, 42 insertions(+), 52 deletions(-)

diff --git a/proxy.h b/proxy.h
index 165c23e5..044ba181 100644
--- a/proxy.h
+++ b/proxy.h
@@ -198,25 +198,24 @@ class destruction_guard {
   T* p_;
 };
 
-template <class P, qualifier_type Q, bool NE>
-struct ptr_traits : inapplicable_traits {};
-template <class P, qualifier_type Q, bool NE>
-    requires(requires { *std::declval<add_qualifier_t<P, Q>>(); } &&
-        (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))
-struct ptr_traits<P, Q, NE> : applicable_traits
-    { using target_type = decltype(*std::declval<add_qualifier_t<P, Q>>()); };
+template <bool IsDirect, class P, qualifier_type Q>
+struct operand_traits : add_qualifier_traits<P, Q> {};
+template <class P, qualifier_type Q>
+struct operand_traits<false, P, Q>
+    : std::type_identity<decltype(*std::declval<add_qualifier_t<P, Q>>())> {};
+template <bool IsDirect, class P, qualifier_type Q>
+using operand_t = typename operand_traits<IsDirect, P, Q>::type;
 
 template <class D, bool NE, class R, class... Args>
 concept invocable_dispatch = (NE && std::is_nothrow_invocable_r_v<
     R, D, Args...>) || (!NE && std::is_invocable_r_v<R, D, Args...>);
-template <class D, class P, qualifier_type Q, bool NE, class R, class... Args>
-concept invocable_dispatch_ptr_indirect = ptr_traits<P, Q, NE>::applicable &&
-    invocable_dispatch<
-        D, NE, R, typename ptr_traits<P, Q, NE>::target_type, Args...>;
-template <class D, class P, qualifier_type Q, bool NE, class R, class... Args>
-concept invocable_dispatch_ptr_direct = invocable_dispatch<
-    D, NE, R, add_qualifier_t<P, Q>, Args...> && (Q != qualifier_type::rv ||
-        (NE && std::is_nothrow_destructible_v<P>) ||
+template <bool IsDirect, class D, class P, qualifier_type Q, bool NE, class R,
+    class... Args>
+concept invocable_dispatch_ptr =
+    (IsDirect || (requires { *std::declval<add_qualifier_t<P, Q>>(); } &&
+        (!NE || noexcept(*std::declval<add_qualifier_t<P, Q>>())))) &&
+    invocable_dispatch<D, NE, R, operand_t<IsDirect, P, Q>, Args...> &&
+    (Q != qualifier_type::rv || (NE && std::is_nothrow_destructible_v<P>) ||
         (!NE && std::is_destructible_v<P>));
 
 template <class D, class R, class... Args>
@@ -227,25 +226,27 @@ R invoke_dispatch(Args&&... args) {
     return D{}(std::forward<Args>(args)...);
   }
 }
-template <class D, class P, qualifier_type Q, class R, class... Args>
-R indirect_conv_dispatcher(add_qualifier_t<std::byte, Q> self, Args... args)
-    noexcept(invocable_dispatch_ptr_indirect<D, P, Q, true, R, Args...>) {
-  auto& qp = *std::launder(reinterpret_cast<add_qualifier_ptr_t<P, Q>>(&self));
-  if constexpr (std::is_constructible_v<bool, decltype(qp)>) { assert(qp); }
-  return invoke_dispatch<D, R>(*std::forward<add_qualifier_t<P, Q>>(qp),
-      std::forward<Args>(args)...);
+template <bool IsDirect, class P, qualifier_type Q, class T>
+decltype(auto) get_operand(T& ptr) {
+  if constexpr (IsDirect) {
+    return std::forward<add_qualifier_t<P, Q>>(ptr);
+  } else {
+    if constexpr (std::is_constructible_v<bool, T&>) { assert(ptr); }
+    return *std::forward<add_qualifier_t<P, Q>>(ptr);
+  }
 }
-template <class D, class P, qualifier_type Q, class R, class... Args>
-R direct_conv_dispatcher(add_qualifier_t<std::byte, Q> self, Args... args)
-    noexcept(invocable_dispatch_ptr_direct<D, P, Q, true, R, Args...>) {
+template <bool IsDirect, class D, class P, qualifier_type Q, class R,
+    class... Args>
+R conv_dispatcher(add_qualifier_t<std::byte, Q> self, Args... args)
+    noexcept(invocable_dispatch_ptr<IsDirect, D, P, Q, true, R, Args...>) {
   auto& qp = *std::launder(reinterpret_cast<add_qualifier_ptr_t<P, Q>>(&self));
   if constexpr (Q == qualifier_type::rv) {
     destruction_guard guard{&qp};
-    return invoke_dispatch<D, R>(
-        std::forward<add_qualifier_t<P, Q>>(qp), std::forward<Args>(args)...);
+    return invoke_dispatch<D, R>(get_operand<IsDirect, P, Q>(qp),
+        std::forward<Args>(args)...);
   } else {
-    return invoke_dispatch<D, R>(
-        std::forward<add_qualifier_t<P, Q>>(qp), std::forward<Args>(args)...);
+    return invoke_dispatch<D, R>(get_operand<IsDirect, P, Q>(qp),
+        std::forward<Args>(args)...);
   }
 }
 template <class D, qualifier_type Q, class R, class... Args>
@@ -263,28 +264,16 @@ struct overload_traits_impl : applicable_traits {
 
   template <bool IsDirect, class D, class P>
   static consteval bool is_applicable_ptr() {
-    if constexpr (IsDirect) {
-      if constexpr (invocable_dispatch_ptr_direct<D, P, Q, NE, R, Args...>) {
-        return true;
-      } else {
-        return invocable_dispatch<D, NE, R, std::nullptr_t, Args...>;
-      }
+    if constexpr (invocable_dispatch_ptr<IsDirect, D, P, Q, NE, R, Args...>) {
+      return true;
     } else {
-      if constexpr (invocable_dispatch_ptr_indirect<D, P, Q, NE, R, Args...>) {
-        return true;
-      } else {
-        return invocable_dispatch<D, NE, R, std::nullptr_t, Args...>;
-      }
+      return invocable_dispatch<D, NE, R, std::nullptr_t, Args...>;
     }
   }
   template <bool IsDirect, class D, class P>
   static consteval dispatcher_type get_dispatcher() {
-    if constexpr (!IsDirect &&
-        invocable_dispatch_ptr_indirect<D, P, Q, NE, R, Args...>) {
-      return &indirect_conv_dispatcher<D, P, Q, R, Args...>;
-    } else if constexpr (IsDirect &&
-        invocable_dispatch_ptr_direct<D, P, Q, NE, R, Args...>) {
-      return &direct_conv_dispatcher<D, P, Q, R, Args...>;
+    if constexpr (invocable_dispatch_ptr<IsDirect, D, P, Q, NE, R, Args...>) {
+      return &conv_dispatcher<IsDirect, D, P, Q, R, Args...>;
     } else {
       return &default_conv_dispatcher<D, Q, R, Args...>;
     }
@@ -791,8 +780,7 @@ struct proxy_helper {
   static decltype(auto) invoke(add_qualifier_t<proxy<F>, Q> p, Args&&... args) {
     auto dispatcher = get_meta(p).template invocation_meta<IsDirect, D, O>
         ::dispatcher;
-    if constexpr (
-        IsDirect && overload_traits<O>::qualifier == qualifier_type::rv) {
+    if constexpr (overload_traits<O>::qualifier == qualifier_type::rv) {
       meta_ptr_reset_guard guard{p.meta_};
       return dispatcher(std::forward<add_qualifier_t<std::byte, Q>>(*p.ptr_),
           std::forward<Args>(args)...);
@@ -1327,8 +1315,8 @@ class strong_compact_ptr
       { return std::launder(reinterpret_cast<const T*>(&this->ptr_->value)); }
   T& operator*() & noexcept { return *operator->(); }
   const T& operator*() const& noexcept { return *operator->(); }
-  T&& operator*() && noexcept { return std::move(operator->()); }
-  const T&& operator*() const&& noexcept { return std::move(operator->()); }
+  T&& operator*() && noexcept { return std::move(*operator->()); }
+  const T&& operator*() const&& noexcept { return std::move(*operator->()); }
 
  private:
   explicit strong_compact_ptr(Storage* ptr) noexcept
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index 8ab129d8..ad78f3f2 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -994,5 +994,6 @@ TEST(ProxyCreationTests, TestMakeProxyView) {
   ASSERT_EQ((*p)(), 0);
   ASSERT_EQ((*std::as_const(p))(), 1);
   ASSERT_EQ((*std::move(p))(), 2);
+  p = pro::make_proxy_view<TestFacade>(test_callable);
   ASSERT_EQ((*std::move(std::as_const(p)))(), 3);
 }
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 0aa12b5f..3610138e 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -333,6 +333,7 @@ TEST(ProxyInvocationTests, TestQualifiedConvention_Member) {
   ASSERT_EQ((*p)(), 0);
   ASSERT_EQ((*std::as_const(p))(), 1);
   ASSERT_EQ((*std::move(p))(), 2);
+  p = pro::make_proxy<TestFacade, TestCallable>();
   ASSERT_EQ((*std::move(std::as_const(p)))(), 3);
 }
 
@@ -347,5 +348,6 @@ TEST(ProxyInvocationTests, TestQualifiedConvention_Free) {
   ASSERT_EQ(Dump(*p), "is_const=false, is_ref=true, value=123");
   ASSERT_EQ(Dump(*std::as_const(p)), "is_const=true, is_ref=true, value=123");
   ASSERT_EQ(Dump(*std::move(p)), "is_const=false, is_ref=false, value=123");
+  p = pro::make_proxy<TestFacade>(123);
   ASSERT_EQ(Dump(*std::move(std::as_const(p))), "is_const=true, is_ref=false, value=123");
 }
diff --git a/tests/proxy_rtti_tests.cpp b/tests/proxy_rtti_tests.cpp
index 6a78b0eb..42b0b6fd 100644
--- a/tests/proxy_rtti_tests.cpp
+++ b/tests/proxy_rtti_tests.cpp
@@ -91,8 +91,7 @@ TEST(ProxyRttiTests, TestIndirectCast_Move_Succeed) {
   auto p = pro::make_proxy<details::TestFacade>(v1);
   auto v2 = proxy_cast<std::vector<int>>(std::move(*p));
   ASSERT_EQ(v2, v1);
-  v2 = proxy_cast<std::vector<int>>(std::move(*p));
-  ASSERT_TRUE(v2.empty());
+  ASSERT_FALSE(p.has_value());
 }
 
 TEST(ProxyRttiTests, TestIndirectCast_Move_Fail) {