Reach the trivial copy and relocation by the source facade

A converting initialization asked the destination facade whether the copy
or the relocation is trivial, but the triviality that licenses a byte
copy belongs to the value being moved, which lives in the source. A super
is never stricter than the facade converting to it, so the byte copy was
missed whenever the derived facade was the stricter of the two, and the
value went through the erased invoker instead.

Corrected three lines of the specification along the way. The copy
assignment is not "as if by auto(rhs).swap(*this)", which is not even
formed for a facade that forbids relocation. The converting move
assignment loses the contained value on a throwing relocation exactly as
the move assignment does. The move constructor is noexcept for trivial
relocatability, which its documented signature spelled as an equality.

Author: mingxwa

docs/spec/proxy/assignment.md

@@ -53,10 +53,10 @@ proxy& operator=(P&& ptr)
 Assigns a new value to `proxy` or destroys the contained value.
 
 - `(1)` Destroys the current contained value if it exists. After the call, `*this` does not contain a value.
-- `(2)` Copy assignment operator copies the contained value of `rhs` to `*this`. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any) as if by `auto(rhs).swap(*this)`. The copy assignment is trivial when `F::copyability == constraint_level::trivial` is `true`.
+- `(2)` Copy assignment operator copies the contained value of `rhs` to `*this`. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any). The copy assignment is trivial when `F::copyability == constraint_level::trivial` is `true`.
 - `(3)` Move assignment operator moves the contained value of `rhs` to `*this`. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any). If the move construction throws when `F::relocatability == constraint_level::nontrivial`, `*this` does not contain a value. After move assignment, `rhs` is in a valid state with an unspecified value. The move assignment operator does not participate in overload resolution when `F::copyability == constraint_level::trivial`, falling back to the trivial copy assignment operator.
 - `(4)` Converting copy assignment operator copies the contained value of `rhs` to `*this`, as if by constructing a `proxy` from `rhs` and assigning it. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any). Participates in overload resolution only if `F2` is not `F` and `F` is a super of `F2`, reachable via `typename F2::super_types` transitively.
-- `(5)` Converting move assignment operator moves the contained value of `rhs` to `*this`. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any). After the assignment, `rhs` does not contain a value. Participates in overload resolution only if `F2` is not `F` and `F` is a super of `F2`, reachable via `typename F2::super_types` transitively. The converting move assignment operator does not participate in overload resolution when `F::copyability == constraint_level::trivial`, falling back to `(4)`.
+- `(5)` Converting move assignment operator moves the contained value of `rhs` to `*this`. If `rhs` does not contain a value, it destroys the contained value of `*this` (if any). If the move construction throws when `F::relocatability == constraint_level::nontrivial`, `*this` does not contain a value. After the assignment, `rhs` does not contain a value. Participates in overload resolution only if `F2` is not `F` and `F` is a super of `F2`, reachable via `typename F2::super_types` transitively. The converting move assignment operator does not participate in overload resolution when `F::copyability == constraint_level::trivial`, falling back to `(4)`.
 - `(6)` Let `VP` be `std::decay_t<P>`. Sets the contained value to an object of type `VP`, direct-non-list-initialized with `std::forward<P>(ptr)`. Participates in overload resolution only if `VP` is not a specialization of `proxy` and is a pointer-like type eligible for `proxy` (see [*ProFacade* requirements](../ProFacade.md)). *Since 3.3.0*: If [`proxiable<VP, F>`](../proxiable.md) is `false`, the program is ill-formed and a diagnostic is generated.
 
 ## Return Value

docs/spec/proxy/constructor.md

@@ -15,7 +15,7 @@ proxy(const proxy& rhs)
 
 // (3)
 proxy(proxy&& rhs)
-    noexcept(F::relocatability == constraint_level::nothrow)
+    noexcept(F::relocatability >= constraint_level::nothrow)
     requires(F::relocatability >= constraint_level::nontrivial &&
         F::copyability != constraint_level::trivial);
 

include/proxy/v4/detail/core.h

@@ -1421,7 +1421,7 @@ class proxy : public detail::facade_traits<F>::direct_accessor,
   void initialize(const proxy<F2>& rhs) {
     PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
     if (rhs.has_value()) {
-      if constexpr (F::copyability == constraint_level::trivial) {
+      if constexpr (F2::copyability == constraint_level::trivial) {
         std::uninitialized_copy_n(rhs.ptr_, F2::max_size, ptr_);
       } else {
         invoke<detail::copy_dispatch,
@@ -1438,7 +1438,7 @@ class proxy : public detail::facade_traits<F>::direct_accessor,
     PRO4D_DEBUG(std::ignore = &pro_symbol_guard;)
     if (rhs.has_value()) {
       auto meta = rhs.meta_;
-      if constexpr (F::relocatability == constraint_level::trivial) {
+      if constexpr (F2::relocatability == constraint_level::trivial) {
         std::uninitialized_copy_n(rhs.ptr_, F2::max_size, ptr_);
         rhs.meta_.reset();
       } else {

tests/proxy_lifetime_tests.cpp

@@ -1284,3 +1284,26 @@ TEST(ProxyLifetimeTests, Test_ConvertingCopyAssignment_NoRelocation) {
   ASSERT_TRUE(p2.has_value());
   ASSERT_EQ(ToString(*p2), "Session 2");
 }
+
+TEST(ProxyLifetimeTests, Test_Substitution_TrivialDerived) {
+  struct Super : pro::facade_builder //
+                 ::add_convention<utils::spec::FreeToString,
+                                  std::string() const>                   //
+                 ::support_copy<pro::constraint_level::nothrow>          //
+                 ::support_relocation<pro::constraint_level::nontrivial> //
+                 ::build {};
+  struct Derived : pro::facade_builder                            //
+                   ::add_facade<Super>                            //
+                   ::support_copy<pro::constraint_level::trivial> //
+                   ::restrict_layout<sizeof(int*), alignof(int*)> //
+                   ::build {};
+  static_assert(Derived::max_size < Super::max_size);
+  int v = 123;
+  pro::proxy<Derived> p1 = &v;
+  pro::proxy<Super> p2 = p1;
+  ASSERT_TRUE(p1.has_value());
+  ASSERT_EQ(ToString(*p2), "123");
+  pro::proxy<Super> p3 = std::move(p1);
+  ASSERT_FALSE(p1.has_value());
+  ASSERT_EQ(ToString(*p3), "123");
+}