From 6d14b77e50bd59d6bfdc99d403c8061e1e2dfe1d Mon Sep 17 00:00:00 2001
From: Mingxin Wang <mingxwa@microsoft.com>
Date: Mon, 3 Mar 2025 19:47:52 +0800
Subject: [PATCH] Implement make_proxy_view and optimize `proxiable_target`

---
 proxy.h                        | 59 +++++++++++++++++++---------------
 tests/proxy_creation_tests.cpp | 21 ++++++++++++
 2 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/proxy.h b/proxy.h
index 2d599954..311d2d9f 100644
--- a/proxy.h
+++ b/proxy.h
@@ -1175,6 +1175,23 @@ const proxy<F>&& access_proxy(const A&& a) noexcept {
 
 namespace details {
 
+template <class LR, class CLR, class RR, class CRR>
+struct observer_ptr {
+ public:
+  explicit observer_ptr(LR lr) : lr_(lr) {}
+  observer_ptr(const observer_ptr&) = default;
+  auto operator->() noexcept { return std::addressof(lr_); }
+  auto operator->() const noexcept
+      { return std::addressof(static_cast<CLR>(lr_)); }
+  LR operator*() & noexcept { return static_cast<LR>(lr_); }
+  CLR operator*() const& noexcept { return static_cast<CLR>(lr_); }
+  RR operator*() && noexcept { return static_cast<RR>(lr_); }
+  CRR operator*() const&& noexcept { return static_cast<CRR>(lr_); }
+
+ private:
+  LR lr_;
+};
+
 #if __STDC_HOSTED__
 template <class T, class Alloc, class... Args>
 T* allocate(const Alloc& alloc, Args&&... args) {
@@ -1443,6 +1460,9 @@ constexpr proxy<F> make_proxy_shared_impl(Args&&... args) {
 
 }  // namespace details
 
+template <facade F> struct observer_facade;
+template <facade F> using proxy_view = proxy<observer_facade<F>>;
+
 template <class T, class F>
 concept inplace_proxiable_target = proxiable<details::inplace_ptr<T>, F>;
 
@@ -1470,10 +1490,19 @@ constexpr proxy<F> make_proxy_inplace(T&& value)
       std::in_place, std::forward<T>(value)};
 }
 
-#if __STDC_HOSTED__
 template <class T, class F>
-concept proxiable_target = inplace_proxiable_target<T, F> ||
-    proxiable<details::allocated_ptr<T, std::allocator<void>>, F>;
+concept proxiable_target = proxiable<
+    details::observer_ptr<T&, const T&, T&&, const T&&>, observer_facade<F>>;
+
+template <facade F, class T>
+constexpr proxy_view<F> make_proxy_view(T& value) noexcept {
+  return proxy_view<F>{
+      details::observer_ptr<T&, const T&, T&&, const T&&>{value}};
+}
+
+#if __STDC_HOSTED__
+template <facade F> struct weak_facade;
+template <facade F> using weak_proxy = proxy<weak_facade<F>>;
 
 template <facade F, class T, class Alloc, class... Args>
 constexpr proxy<F> allocate_proxy(const Alloc& alloc, Args&&... args)
@@ -1543,14 +1572,8 @@ constexpr proxy<F> make_proxy_shared(T&& value)
   return details::make_proxy_shared_impl<F, std::decay_t<T>>(
       std::forward<T>(value));
 }
-
-template <facade F> struct weak_facade;
-template <facade F> using weak_proxy = proxy<weak_facade<F>>;
 #endif  // __STDC_HOSTED__
 
-template <facade F> struct observer_facade;
-template <facade F> using proxy_view = proxy<observer_facade<F>>;
-
 #ifdef __cpp_rtti
 class bad_proxy_cast : public std::bad_cast {
  public:
@@ -1905,29 +1928,13 @@ using merge_facade_conv_t = typename add_upward_conversion_conv<
         F::constraints.copyability != constraint_level::trivial) ?
         F::constraints.relocatability : constraint_level::none>::type;
 
-template <class LR, class CLR, class RR, class CRR>
-struct observer_ptr {
- public:
-  explicit observer_ptr(std::remove_reference_t<LR>* ptr) : ptr_(ptr) {}
-  observer_ptr(const observer_ptr&) = default;
-  auto operator->() noexcept { return std::addressof(static_cast<LR>(*ptr_)); }
-  auto operator->() const noexcept
-      { return std::addressof(static_cast<CLR>(*ptr_)); }
-  LR operator*() & noexcept { return static_cast<LR>(*ptr_); }
-  CLR operator*() const& noexcept { return static_cast<CLR>(*ptr_); }
-  RR operator*() && noexcept { return static_cast<RR>(*ptr_); }
-  CRR operator*() const&& noexcept { return static_cast<CRR>(*ptr_); }
-
- private:
-  std::remove_reference_t<LR>* ptr_;
-};
 struct proxy_view_dispatch : cast_dispatch_base<false, true> {
   template <class T>
   auto operator()(T& value) const noexcept
       requires(requires { { std::addressof(*value) } noexcept; }) {
     return observer_ptr<decltype(*value), decltype(*std::as_const(value)),
         decltype(*std::move(value)), decltype(*std::move(std::as_const(value)))>
-        {std::addressof(*value)};
+        {*value};
   }
 };
 
diff --git a/tests/proxy_creation_tests.cpp b/tests/proxy_creation_tests.cpp
index 79605838..7fc21809 100644
--- a/tests/proxy_creation_tests.cpp
+++ b/tests/proxy_creation_tests.cpp
@@ -972,3 +972,24 @@ TEST(ProxyCreationTests, TestStdWeakPtrCompatibility) {
   }
   ASSERT_TRUE(tracker.GetOperations() == expected_ops);
 }
+
+TEST(ProxyCreationTests, TestMakeProxyView) {
+  struct TestFacade : pro::facade_builder
+      ::add_convention<pro::operator_dispatch<"()">, int()&, int() const&, int() && noexcept, int() const&&>
+      ::build {};
+
+  struct {
+    int operator()()& noexcept { return 0; }
+    int operator()() const& noexcept { return 1; }
+    int operator()() && noexcept { return 2; }
+    int operator()() const&& noexcept { return 3; }
+  } test_callable;
+
+  pro::proxy_view<TestFacade> p = pro::make_proxy_view<TestFacade>(test_callable);
+  static_assert(!noexcept((*p)()));
+  static_assert(noexcept((*std::move(p))()));
+  ASSERT_EQ((*p)(), 0);
+  ASSERT_EQ((*std::as_const(p))(), 1);
+  ASSERT_EQ((*std::move(p))(), 2);
+  ASSERT_EQ((*std::move(std::as_const(p)))(), 3);
+}