libstdc++: Implement C++26 std::polymorphic [PR119152]

This patch implements C++26 std::polymorphic as specified in P3019 with
amendment to move assignment from LWG 4251.

The implementation always allocate stored object on the heap. The manager
function (_M_manager) is similary keep with the object (polymorphic::_Obj),
which reduces the size of the polymorphic to size of the single pointer plus
allocator (that is declared with [[no_unique_address]]).

The implementation does not not use small-object optimization (SSO). We may
consider adding this in the future, as SSO is allowed by the standard. However,
storing any polimorphic object will require providing space for two pointers
(manager function and vtable pointer) and user-declared data members.

	PR libstdc++/119152

libstdc++-v3/ChangeLog:

	* include/bits/indirect.h (std::polymorphic, pmr::polymorphic)
	[__glibcxx_polymorphic]: Define.
	* include/bits/version.def (polymorphic): Define.
	* include/bits/version.h: Regenerate.
	* include/std/memory: Define __cpp_lib_polymorphic.
	* testsuite/std/memory/polymorphic/copy.cc: New test.
	* testsuite/std/memory/polymorphic/copy_alloc.cc: New test.
	* testsuite/std/memory/polymorphic/ctor.cc: New test.
	* testsuite/std/memory/polymorphic/ctor_poly.cc: New test.
	* testsuite/std/memory/polymorphic/incomplete.cc: New test.
	* testsuite/std/memory/polymorphic/invalid_neg.cc: New test.
	* testsuite/std/memory/polymorphic/move.cc: New test.
	* testsuite/std/memory/polymorphic/move_alloc.cc: New test.

Co-authored-by: Tomasz Kamiński <tkaminsk@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

8 files changed, 1394 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/copy.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/copy.cc
new file mode 100644
index 0000000..bea05ac
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/copy.cc
@@ -0,0 +1,157 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct Base {
+  friend constexpr
+  bool operator==(const Base& lhs, const Base& rhs)
+  { return lhs.eq(rhs); }
+
+private:
+  constexpr virtual bool
+  eq(const Base& other) const = 0;
+};
+
+struct Derived : Base
+{
+  constexpr Derived()
+   : x(0), y(0), z(0)
+  { }
+
+  constexpr Derived(int a, int b, int c)
+   : x(a), y(b), z(c)
+  { }
+      
+private:
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const Derived*>(&other))
+      return this->x == op->x && this->y == op->y && this->z == op->z;
+    return false;
+  }
+
+  int x;
+  int y;
+  int z;
+};
+
+using __gnu_test::tracker_allocator;
+using Counter = __gnu_test::tracker_allocator_counter;
+using Polymorhic = std::polymorphic<Base, tracker_allocator<Base>>;
+const Polymorhic src(std::in_place_type<Derived>, 1, 2, 3);
+
+constexpr void
+test_ctor()
+{
+  Counter::reset();
+  Polymorhic i1(src);
+  VERIFY( *i1 == *src );
+  VERIFY( &*i1 != &*src );
+  VERIFY( Counter::get_allocation_count() >= sizeof(Derived) );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Counter::reset();
+  Polymorhic i2(std::allocator_arg, {}, src);
+  VERIFY( *i2 == *src );
+  VERIFY( &*i2 != &*src );
+  VERIFY( Counter::get_allocation_count() >= sizeof(Derived) );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+constexpr void
+test_assign()
+{
+  Counter::reset();
+  Polymorhic i1(std::in_place_type<Derived>);
+  const size_t holderSize = Counter::get_allocation_count();
+  VERIFY( holderSize >= sizeof(Derived) );
+  Counter::reset();
+
+  i1 = src;
+  VERIFY( *i1 == *src );
+  VERIFY( &*i1 != &*src );
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == holderSize );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  auto(std::move(i1));
+  Counter::reset();
+
+  i1 = src;
+  VERIFY( *i1 == *src );
+  VERIFY( &*i1 != &*src );
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+constexpr void
+test_valueless()
+{
+  Polymorhic e(std::in_place_type<Derived>);
+  auto(std::move(e));
+  VERIFY( e.valueless_after_move() );
+
+  Counter::reset();
+  Polymorhic i1(e);
+  VERIFY( i1.valueless_after_move() );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Polymorhic i2(std::allocator_arg, {}, e);
+  VERIFY( i2.valueless_after_move() );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Polymorhic i3(src);
+  Counter::reset();
+  i3 = e;
+  VERIFY( i3.valueless_after_move() );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() >= sizeof(Derived) );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Counter::reset();
+  i3 = e;
+  VERIFY( i3.valueless_after_move() );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+constexpr void
+test_all()
+{
+  test_ctor();
+  test_assign();
+  test_valueless();
+}
+
+int main()
+{
+  test_all();
+
+  static_assert([] {
+    test_all();
+    return true;
+  });
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/copy_alloc.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/copy_alloc.cc
new file mode 100644
index 0000000..f41c32e
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/copy_alloc.cc
@@ -0,0 +1,270 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct Base {
+  friend constexpr
+  bool operator==(const Base& lhs, const Base& rhs)
+  { return lhs.eq(rhs); }
+
+  virtual constexpr int
+  get_alloc_personality() const
+  { return -1; }
+
+private:
+  constexpr virtual bool
+  eq(const Base& other) const = 0;
+};
+
+template<typename T, typename Allocator>
+struct VecDerived : Base, std::vector<T, Allocator>
+{
+  using VecBase = std::vector<T, Allocator>;
+
+  using VecBase::VecBase;
+
+  constexpr int
+  get_alloc_personality() const override
+  { return this->get_allocator().get_personality(); }
+
+private:
+
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const VecDerived*>(&other))
+      return *static_cast<const VecBase*>(this)
+	       == *static_cast<const VecBase*>(op);
+    return false;
+  }
+};
+
+using __gnu_test::propagating_allocator;
+using __gnu_test::tracker_allocator;
+using Counter = __gnu_test::tracker_allocator_counter;
+
+template<bool Propagate>
+constexpr void
+test_ctor()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  const Polymorphic src(std::allocator_arg, ScopedAlloc{11, 22},
+		     std::in_place_type<Vector>, {1, 2, 3});
+
+  Counter::reset();
+  Polymorphic i1(src);
+  VERIFY( *i1 == *src );
+  VERIFY( &*i1 != &*src );
+  if (Propagate)
+  {
+    VERIFY( i1->get_alloc_personality() == 22 );
+    VERIFY( i1.get_allocator().get_personality() == 11 );
+  }
+  else
+  {
+    VERIFY( i1->get_alloc_personality() == 0 );
+    VERIFY( i1.get_allocator().get_personality() == 0 );
+  }
+  VERIFY( Counter::get_allocation_count() >= sizeof(Vector) );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+
+  Counter::reset();
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{33, 44}, src);
+  VERIFY( *i2 == *src );
+  VERIFY( &*i2 != &*src );
+  VERIFY( i2->get_alloc_personality() == 44 );
+  VERIFY( i2.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() >= sizeof(Vector) );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_assign()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  const Polymorphic src(std::allocator_arg, ScopedAlloc{11, 22},
+		     std::in_place_type<Vector>, {1, 2, 3});
+
+  Counter::reset();
+  Polymorphic i1(std::allocator_arg, ScopedAlloc{11, 22},
+	         std::in_place_type<Vector>);
+  const size_t holderSize = Counter::get_allocation_count();
+  VERIFY( holderSize >= sizeof(Vector) );
+  Counter::reset();
+
+  i1 = src;
+  VERIFY( *i1 == *src );
+  VERIFY( &*i1 != &*src );
+  VERIFY( i1->get_alloc_personality() == 22 );
+  VERIFY( i1.get_allocator().get_personality() == 11 );
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == holderSize );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{33, 44});
+  Counter::reset();
+
+  i2 = src;
+  VERIFY( *i2 == *src );
+  VERIFY( &*i2 != &*src );
+  if (Propagate)
+  {
+    VERIFY( i2->get_alloc_personality() == 22 );
+    VERIFY( i2.get_allocator().get_personality() == 11 );
+  }
+  else
+  {
+    VERIFY( i2->get_alloc_personality() == 44 );
+    VERIFY( i2.get_allocator().get_personality() == 33 );
+  }
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == holderSize );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{11, 22});
+  auto(std::move(i3));
+  Counter::reset();
+
+  i3 = src;
+  VERIFY( *i3 == *src );
+  VERIFY( &*i3 != &*src );
+  VERIFY( i3->get_alloc_personality() == 22 );
+  VERIFY( i3.get_allocator().get_personality() == 11 );
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Polymorphic i4(std::allocator_arg, ScopedAlloc{33, 44});
+  auto(std::move(i4));
+  Counter::reset();
+
+  i4 = src;
+  VERIFY( *i4 == *src );
+  VERIFY( &*i4 != &*src );
+  if (Propagate)
+  {
+    VERIFY( i4->get_alloc_personality() == 22 );
+    VERIFY( i4.get_allocator().get_personality() == 11 );
+  }
+  else
+  {
+    VERIFY( i4->get_alloc_personality() == 44 );
+    VERIFY( i4.get_allocator().get_personality() == 33 );
+  }
+  VERIFY( Counter::get_allocation_count() == holderSize );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_valueless()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  Polymorphic e(std::allocator_arg, ScopedAlloc{11, 22},
+	     std::in_place_type<Vector>);
+  auto(std::move(e));
+  VERIFY( e.valueless_after_move() );
+
+  Counter::reset();
+  Polymorphic i1(e);
+  VERIFY( i1.valueless_after_move() );
+  if (Propagate)
+    VERIFY( i1.get_allocator().get_personality() == 11 );
+  else
+    VERIFY( i1.get_allocator().get_personality() == 0 );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Counter::reset();
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{33, 44}, e);
+  VERIFY( i2.valueless_after_move() );
+  VERIFY( i2.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{33, 44});
+  Counter::reset();
+
+  i3 = e;
+  VERIFY( i3.valueless_after_move() );
+  if (Propagate)
+    VERIFY( i3.get_allocator().get_personality() == 11 );
+  else
+    VERIFY( i3.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() ==  0 );
+  VERIFY( Counter::get_deallocation_count() >= sizeof(Vector) );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Counter::reset();
+  i2 = e;
+  VERIFY( i2.valueless_after_move() );
+  if (Propagate)
+    VERIFY( i2.get_allocator().get_personality() == 11 );
+  else
+    VERIFY( i2.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_all()
+{
+  test_ctor<Propagate>();
+  test_assign<Propagate>();
+  test_valueless<Propagate>();
+}
+
+int main()
+{
+  test_all<true>();
+  test_all<false>();
+
+  static_assert([] {
+    test_all<true>();
+    test_all<false>();
+    return true;
+  });
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/ctor.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/ctor.cc
new file mode 100644
index 0000000..bb4c947
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/ctor.cc
@@ -0,0 +1,190 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+
+#ifndef __cpp_lib_polymorphic
+# error __cpp_lib_polymorphic feature test macro missing in <memory>
+#elif __cpp_lib_polymorphic != 202502
+# error __cpp_lib_polymorphic feature test macro has wrong value in <memory>
+#endif
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+using __gnu_test::uneq_allocator;
+using UneqAlloc = uneq_allocator<int>;
+using ScopedAlloc = std::scoped_allocator_adaptor<
+  uneq_allocator<std::vector<int, UneqAlloc>>,
+  UneqAlloc>;
+
+struct Obj
+{
+  int i;
+  char c[2];
+};
+
+constexpr void
+test_default_ctor()
+{
+  using __gnu_test::default_init_allocator;
+
+  std::polymorphic<Obj, default_init_allocator<Obj>> i1;
+  default_init_allocator<int> a{};
+
+  // The contained object and the allocator should be value-initialized.
+  VERIFY( i1->i == 0 );
+  VERIFY( i1->c[0] == 0 );
+  VERIFY( i1->c[1] == 0 );
+  VERIFY( i1.get_allocator() == a );
+
+  a.state = 5;
+  // Allocator-extended default constructor:
+  std::polymorphic<Obj, default_init_allocator<Obj>> i2(std::allocator_arg, a);
+  VERIFY( i2.get_allocator() == a );
+
+  // Object is constructed using allocator-aware constructor.
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i3(std::allocator_arg, ScopedAlloc(11, 22));
+  VERIFY( i3->empty() );
+  VERIFY( i3->get_allocator().get_personality() == 22 );
+  VERIFY( i3.get_allocator().get_personality() == 11 );
+}
+
+constexpr void
+test_forwarding_ctor()
+{
+  Obj obj{1, {'2', '3'}};
+  auto verify = [](std::polymorphic<Obj> const& i)
+  {
+    VERIFY( i->i == 1 );
+    VERIFY( i->c[0] == '2' );
+    VERIFY( i->c[1] == '3' );
+  };
+
+  std::polymorphic<Obj> i1(std::as_const(obj));
+  verify(i1);
+  std::polymorphic<Obj> i2(std::move(std::as_const(obj)));
+  verify(i2);
+  std::polymorphic<Obj> i3(obj);
+  verify(i3);
+  std::polymorphic<Obj> i4(std::move(obj));
+  verify(i4);
+
+  std::polymorphic<Obj> i5({1, {'2', '3'}});
+  verify(i5);
+
+  std::vector<int, UneqAlloc> v{1, 2, 3, 4, 5};
+  // Object is constructed using allocator-aware constructor.
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i7(std::allocator_arg, ScopedAlloc(11, 22), v);
+  VERIFY( i7->size() == 5  );
+  VERIFY( v.size() == 5 );
+  VERIFY( i7->get_allocator().get_personality() == 22 );
+  VERIFY( i7.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i8(std::allocator_arg, ScopedAlloc(11, 22), std::move(v));
+  VERIFY( i8->size() == 5  );
+  VERIFY( v.size() == 0 );
+  VERIFY( i8->get_allocator().get_personality() == 22 );
+  VERIFY( i8.get_allocator().get_personality() == 11 );
+}
+
+constexpr void
+test_inplace_ctor()
+{
+  std::polymorphic<Obj> i1(std::in_place_type<Obj>);
+  VERIFY( i1->i == 0 );
+  VERIFY( i1->c[0] == 0 );
+  VERIFY( i1->c[1] == 0 );
+
+  std::polymorphic<Obj> i2(std::in_place_type<Obj>, 10);
+  VERIFY( i2->i == 10 );
+  VERIFY( i2->c[0] == 0 );
+  VERIFY( i2->c[1] == 0 );
+
+  std::polymorphic<Obj, uneq_allocator<Obj>>
+    i3(std::allocator_arg, 42, std::in_place_type<Obj>);
+  VERIFY( i3->i == 0 );
+  VERIFY( i3->c[0] == 0 );
+  VERIFY( i3->c[1] == 0 );
+  VERIFY( i3.get_allocator().get_personality() == 42 );
+
+  std::polymorphic<Obj,  uneq_allocator<Obj>>
+    i4(std::allocator_arg, 42, std::in_place_type<Obj>, 10);
+  VERIFY( i4->i == 10 );
+  VERIFY( i4->c[0] == 0 );
+  VERIFY( i4->c[1] == 0 );
+  VERIFY( i4.get_allocator().get_personality() == 42 );
+
+  std::polymorphic<std::vector<int>>
+    i5(std::in_place_type<std::vector<int>>);
+  VERIFY( i5->size() == 0 );
+
+  std::polymorphic<std::vector<int>>
+    i6(std::in_place_type<std::vector<int>>, 5, 13);
+  VERIFY( i6->size() == 5 );
+  VERIFY( i6->at(0) == 13 );
+
+  std::polymorphic<std::vector<int>>
+    i7(std::in_place_type<std::vector<int>>, {1, 2, 3, 4});
+  VERIFY( i7->size() == 4 );
+  VERIFY( i7->at(2) == 3 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>>
+    i8(std::in_place_type<std::vector<int, UneqAlloc>>, UneqAlloc{42});
+  VERIFY( i8->size() == 0 );
+  VERIFY( i8->get_allocator().get_personality() == 42 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>>
+    i9(std::in_place_type<std::vector<int, UneqAlloc>>, 5, 13, UneqAlloc{42});
+  VERIFY( i9->size() == 5 );
+  VERIFY( i9->at(0) == 13 );
+  VERIFY( i9->get_allocator().get_personality() == 42 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>>
+    i10(std::in_place_type<std::vector<int, UneqAlloc>>, {1, 2, 3, 4}, UneqAlloc{42});
+  VERIFY( i10->size() == 4 );
+  VERIFY( i10->at(2) == 3 );
+  VERIFY( i10->get_allocator().get_personality() == 42 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i14(std::allocator_arg, ScopedAlloc(11, 22),
+	std::in_place_type<std::vector<int, UneqAlloc>>);
+  VERIFY( i14->size() == 0 );
+  VERIFY( i14->get_allocator().get_personality() == 22 );
+  VERIFY( i14.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i15(std::allocator_arg, ScopedAlloc(11, 22),
+	std::in_place_type<std::vector<int, UneqAlloc>>, 5, 13);
+  VERIFY( i15->size() == 5 );
+  VERIFY( i15->at(0) == 13 );
+  VERIFY( i15->get_allocator().get_personality() == 22 );
+  VERIFY( i15.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<std::vector<int, UneqAlloc>, ScopedAlloc>
+    i16(std::allocator_arg, ScopedAlloc(11, 22),
+	std::in_place_type<std::vector<int, UneqAlloc>>, {1, 2, 3, 4});
+  VERIFY( i16->size() == 4 );
+  VERIFY( i16->at(2) == 3 );
+  VERIFY( i16->get_allocator().get_personality() == 22 );
+  VERIFY( i16.get_allocator().get_personality() == 11 );
+}
+
+int main()
+{
+  test_default_ctor();
+  test_forwarding_ctor();
+  test_inplace_ctor();
+
+  static_assert([] {
+    test_default_ctor();
+    test_forwarding_ctor();
+    test_inplace_ctor();
+    return true;
+  });
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/ctor_poly.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/ctor_poly.cc
new file mode 100644
index 0000000..03519a1
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/ctor_poly.cc
@@ -0,0 +1,220 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+
+#ifndef __cpp_lib_polymorphic
+# error __cpp_lib_polymorphic feature test macro missing in <memory>
+#elif __cpp_lib_polymorphic != 202502
+# error __cpp_lib_polymorphic feature test macro has wrong value in <memory>
+#endif
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct Base {
+  friend constexpr
+  bool operator==(const Base& lhs, const Base& rhs)
+  { return lhs.eq(rhs); }
+
+  virtual constexpr int
+  get_personality() const
+  { return -1; }
+
+private:
+  constexpr virtual bool
+  eq(const Base& other) const
+  { return true; }
+};
+
+struct ObjDerived : Base
+{
+  constexpr ObjDerived()
+   : x(0), y(0), z(0)
+  { }
+
+  constexpr ObjDerived(int a, int b, int c)
+   : x(a), y(b), z(c)
+  { }
+
+  virtual constexpr int
+  get_personality() const
+  { return -2; }
+
+private:
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const ObjDerived*>(&other))
+      return this->x == op->x && this->y == op->y && this->z == op->z;
+    return false;
+  }
+
+  int x;
+  int y;
+  int z;
+};
+
+template<typename T, typename Allocator>
+struct VecDerived : Base, std::vector<T, Allocator>
+{
+  using VecBase = std::vector<T, Allocator>;
+
+  using VecBase::VecBase;
+
+  constexpr int
+  get_personality() const override
+  { return this->get_allocator().get_personality(); }
+
+private:
+
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const VecDerived*>(&other))
+      return *static_cast<const VecBase*>(this)
+	       == *static_cast<const VecBase*>(op);
+    return false;
+  }
+};
+
+using __gnu_test::uneq_allocator;
+using UneqAlloc = uneq_allocator<int>;
+using ScopedAlloc = std::scoped_allocator_adaptor<
+  uneq_allocator<Base>,
+  UneqAlloc>;
+
+constexpr void
+test_default_ctor()
+{
+  using __gnu_test::default_init_allocator;
+
+  std::polymorphic<Base, default_init_allocator<Base>> i1;
+  default_init_allocator<int> a{};
+
+  // The contained object and the allocator should be value-initialized.
+  VERIFY( *i1 == Base() );
+  VERIFY( i1->get_personality() == -1 );
+  VERIFY( i1.get_allocator() == a );
+
+  a.state = 5;
+  // Allocator-extended default constructor:
+  std::polymorphic<Base, default_init_allocator<Base>> i2(std::allocator_arg, a);
+  VERIFY( *i1 == Base() );
+  VERIFY( i1->get_personality() == -1 );
+}
+
+constexpr void
+test_forwarding_ctor()
+{
+  const ObjDerived src(1, 2, 3);
+ 
+  std::polymorphic<Base> i1(src);
+  VERIFY( *i1 == src );
+  VERIFY( i1->get_personality() == -2 );
+  std::polymorphic<Base> i2(std::move(src));
+  VERIFY( *i2 == src );
+  VERIFY( i2->get_personality() == -2 );
+  
+  ObjDerived obj = src;
+  std::polymorphic<Base> i3(obj);
+  VERIFY( *i3 == src );
+  VERIFY( i3->get_personality() == -2 );
+  std::polymorphic<Base> i4(std::move(obj));
+  VERIFY( *i4 == src );
+  VERIFY( i4->get_personality() == -2 );
+
+  const VecDerived<int, UneqAlloc> v{1, 2, 3, 4, 5};
+  // Object is constructed using allocator-aware constructor.
+  std::polymorphic<Base, ScopedAlloc>
+    i5(std::allocator_arg, ScopedAlloc(11, 22), v);
+  VERIFY( *i5 == v );
+  VERIFY( i5->get_personality() == 22 );
+  VERIFY( i5.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<Base, ScopedAlloc>
+    i6(std::allocator_arg, ScopedAlloc(11, 22), auto(v));
+  VERIFY( *i6 == v  );
+  VERIFY( i6->get_personality() == 22 );
+  VERIFY( i6.get_allocator().get_personality() == 11 );
+}
+
+constexpr void
+test_inplace_ctor()
+{
+  std::polymorphic<Base> i1(std::in_place_type<ObjDerived>);
+  VERIFY( *i1 == ObjDerived() );
+  VERIFY( i1->get_personality() == -2 );
+
+  std::polymorphic<Base> i2(std::in_place_type<ObjDerived>, 10, 20, 30);
+  VERIFY( *i2 == ObjDerived(10, 20, 30) );
+  VERIFY( i2->get_personality() == -2 );
+
+  std::polymorphic<Base, uneq_allocator<Base>>
+    i3(std::allocator_arg, 42, std::in_place_type<ObjDerived>);
+  VERIFY( *i3 == ObjDerived() );
+  VERIFY( i3->get_personality() == -2 );
+  VERIFY( i3.get_allocator().get_personality() == 42 );
+
+  std::polymorphic<Base, uneq_allocator<Base>>
+    i4(std::allocator_arg, 42, std::in_place_type<ObjDerived>, 10, 20, 30);
+  VERIFY( *i4 == ObjDerived(10, 20, 30) );
+  VERIFY( i4->get_personality() == -2 );
+  VERIFY( i4.get_allocator().get_personality() == 42 );
+
+  const VecDerived<int, UneqAlloc> ze;
+  const VecDerived<int, UneqAlloc> fe(5, 13);
+  const VecDerived<int, UneqAlloc> il{1, 2, 3 ,4};
+
+  std::polymorphic<Base>
+    i5(std::in_place_type<VecDerived<int, UneqAlloc>>, UneqAlloc{42});
+  VERIFY( *i5 == ze );
+  VERIFY( i5->get_personality() == 42 );
+ 
+  std::polymorphic<Base>
+    i6(std::in_place_type<VecDerived<int, UneqAlloc>>, 5, 13, UneqAlloc{42});
+  VERIFY( *i6 == fe );
+  VERIFY( i6->get_personality() == 42 );
+
+  std::polymorphic<Base>
+    i7(std::in_place_type<VecDerived<int, UneqAlloc>>, {1, 2, 3, 4}, UneqAlloc{42});
+  VERIFY( *i7 == il  );
+  VERIFY( i7->get_personality() == 42 );
+
+  std::polymorphic<Base, ScopedAlloc>
+    i8(std::allocator_arg, ScopedAlloc(11, 22),
+	std::in_place_type<VecDerived<int, UneqAlloc>>);
+  VERIFY( *i8 == ze );
+  VERIFY( i8->get_personality() == 22 );
+  VERIFY( i8.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<Base, ScopedAlloc>
+    i9(std::allocator_arg, ScopedAlloc(11, 22),
+       std::in_place_type<VecDerived<int, UneqAlloc>>, 5, 13);
+  VERIFY( *i9 == fe );
+  VERIFY( i9->get_personality() == 22 );
+  VERIFY( i9.get_allocator().get_personality() == 11 );
+
+  std::polymorphic<Base, ScopedAlloc>
+    i10(std::allocator_arg, ScopedAlloc(11, 22),
+	std::in_place_type<VecDerived<int, UneqAlloc>>, {1, 2, 3, 4});
+  VERIFY( *i10 == il );
+  VERIFY( i10->get_personality() == 22 );
+  VERIFY( i10.get_allocator().get_personality() == 11 );
+}
+
+int main()
+{
+  test_default_ctor();
+  test_forwarding_ctor();
+  test_inplace_ctor();
+
+  static_assert([] {
+    test_default_ctor();
+    test_forwarding_ctor();
+    test_inplace_ctor();
+    return true;
+  });
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/incomplete.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/incomplete.cc
new file mode 100644
index 0000000..e5dd78f
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/incomplete.cc
@@ -0,0 +1,13 @@
+// { dg-do compile { target c++26 } }
+
+#include <memory>
+
+struct Incomplete;
+
+std::polymorphic<Incomplete>*
+test_move(std::polymorphic<Incomplete>& i1, std::polymorphic<Incomplete>& i2)
+{
+  i1 = std::move(i2);
+  swap(i1, i2);
+  return new std::polymorphic<Incomplete>(std::move(i1));
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/invalid_neg.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/invalid_neg.cc
new file mode 100644
index 0000000..a01af3f
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/invalid_neg.cc
@@ -0,0 +1,28 @@
+// { dg-do compile { target c++26 } }
+
+#include <memory>
+
+// In every specialization polymorphic<T, Allocator>, if the type
+// allocator_traits<Allocator>::value_type is not the same type as T,
+// the program is ill-formed.
+using T1 = std::polymorphic<int, std::allocator<long>>::value_type; // { dg-error "here" }
+
+// A program that instantiates the definition of the template
+// polymorphic<T, Allocator> with a type for the T parameter that is
+// a non-object type, an array type, in_place_t,
+// a specialization of in_place_type_t, or a cv-qualified type is ill-formed.
+
+using T2 = std::polymorphic<int&>::value_type; // { dg-error "here" }
+
+using T3 = std::polymorphic<int[1]>::value_type; // { dg-error "here" }
+
+using T4 = std::polymorphic<std::in_place_t>::value_type; // { dg-error "here" }
+
+using T5 = std::polymorphic<std::in_place_type_t<int>>::value_type; // { dg-error "here" }
+
+using T6 = std::polymorphic<const int>::value_type; // { dg-error "here" }
+
+using T7 = std::polymorphic<volatile int>::value_type; // { dg-error "here" }
+
+// { dg-error "static assertion failed" "" { target *-*-* } 0 }
+// { dg-prune-output "forming pointer to reference" }
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/move.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/move.cc
new file mode 100644
index 0000000..c802159
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/move.cc
@@ -0,0 +1,177 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+#include <optional>
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct Base {
+  friend constexpr
+  bool operator==(const Base& lhs, const Base& rhs)
+  { return lhs.eq(rhs); }
+
+private:
+  constexpr virtual bool
+  eq(const Base& other) const = 0;
+};
+
+struct Derived : Base
+{
+  constexpr Derived()
+   : x(0), y(0), z(0)
+  { }
+
+  constexpr Derived(int a, int b, int c)
+   : x(a), y(b), z(c)
+  { }
+      
+private:
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const Derived*>(&other))
+      return this->x == op->x && this->y == op->y && this->z == op->z;
+    return false;
+  }
+
+  int x;
+  int y;
+  int z;
+};
+
+using __gnu_test::tracker_allocator;
+using Counter = __gnu_test::tracker_allocator_counter;
+using Polymorphic = std::polymorphic<Base, tracker_allocator<Base>>;
+const Polymorphic val(std::in_place_type<Derived>, 1, 2, 3);
+
+constexpr void
+verifyNoAllocations()
+{
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+constexpr void
+test_ctor()
+{
+  std::optional<Polymorphic> src;
+  auto make = [&src] -> Polymorphic&& {
+    src.emplace(val);
+    Counter::reset();
+    return std::move(*src);
+  };
+
+  Polymorphic i1(make());
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i1 == *val );
+  verifyNoAllocations();
+
+  Polymorphic i2(std::allocator_arg, {}, make());
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i2 == *val );
+  verifyNoAllocations();
+}
+
+constexpr void
+test_assign()
+{
+  std::optional<Polymorphic> src;
+  auto make = [&src] -> Polymorphic&& {
+    src.emplace(val);
+    Counter::reset();
+    return std::move(*src);
+  };
+
+  Polymorphic i1(std::in_place_type<Derived>);
+
+  i1 = make();
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i1 == *val );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() >= sizeof(Derived) );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  auto(std::move(i1));
+  i1 = make();
+  VERIFY( *i1 == *val );
+  VERIFY( src->valueless_after_move() );
+  verifyNoAllocations();
+}
+
+constexpr void
+test_swap()
+{
+  const Polymorphic val1(std::in_place_type<Derived>, 1, 2, 3);
+  const Polymorphic val2(std::in_place_type<Derived>, 2, 4, 6);
+
+  Polymorphic i1(val1);
+  Polymorphic i2(val2);
+  Counter::reset();
+  i1.swap(i2);
+  VERIFY( *i2 == *val1 );
+  VERIFY( *i1 == *val2 );
+  verifyNoAllocations();
+
+  auto(std::move(i1));
+  
+  Counter::reset();
+  i1.swap(i2);
+  VERIFY( *i1 == *val1 );
+  VERIFY( i2.valueless_after_move() );
+  verifyNoAllocations();
+}
+
+constexpr void
+test_valueless()
+{
+  auto e = [] {
+    Polymorphic res(std::in_place_type<Derived>);
+    auto(std::move(res));
+    Counter::reset();
+    return res;
+  };
+
+  Polymorphic i1(e());
+  VERIFY( i1.valueless_after_move() );
+  verifyNoAllocations();
+
+  Polymorphic i2(std::allocator_arg, {}, e());
+  VERIFY( i2.valueless_after_move() );
+  verifyNoAllocations();
+
+  Polymorphic i3(val);
+  i3 = e();
+  VERIFY( Counter::get_allocation_count() ==  0 );
+  VERIFY( Counter::get_deallocation_count() >= sizeof(Derived) );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  i3 = e();
+  verifyNoAllocations();
+}
+
+constexpr void
+test_all()
+{
+  test_ctor();
+  test_assign();
+  test_swap();
+  test_valueless();
+}
+
+int main()
+{
+  test_all();
+
+  static_assert([] {
+    test_all();
+    return true;
+  });
+}
diff --git a/libstdc++-v3/testsuite/std/memory/polymorphic/move_alloc.cc b/libstdc++-v3/testsuite/std/memory/polymorphic/move_alloc.cc
new file mode 100644
index 0000000..09afedb
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/memory/polymorphic/move_alloc.cc
@@ -0,0 +1,339 @@
+// { dg-do run { target c++26 } }
+
+#include <memory>
+#include <scoped_allocator>
+#include <utility>
+#include <vector>
+#include <optional>
+
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+struct Base {
+  friend constexpr
+  bool operator==(const Base& lhs, const Base& rhs)
+  { return lhs.eq(rhs); }
+
+  virtual constexpr int
+  get_alloc_personality() const
+  { return -1; }
+
+private:
+  constexpr virtual bool
+  eq(const Base& other) const = 0;
+};
+
+template<typename T, typename Allocator>
+struct VecDerived : Base, std::vector<T, Allocator>
+{
+  using VecBase = std::vector<T, Allocator>;
+
+  using VecBase::VecBase;
+
+  constexpr int
+  get_alloc_personality() const override
+  { return this->get_allocator().get_personality(); }
+
+private:
+
+  constexpr bool
+  eq(const Base& other) const override
+  { 
+    if (auto op = dynamic_cast<const VecDerived*>(&other))
+      return *static_cast<const VecBase*>(this)
+	       == *static_cast<const VecBase*>(op);
+    return false;
+  }
+};
+
+using __gnu_test::propagating_allocator;
+using __gnu_test::tracker_allocator;
+using Counter = __gnu_test::tracker_allocator_counter;
+
+constexpr void
+verifyNoAllocations()
+{
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_ctor()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  const Polymorphic val(std::in_place_type<Vector>, {1, 2, 3});
+  std::optional<Polymorphic> src;
+  auto make = [&val, &src] -> Polymorphic&& {
+    src.emplace(std::allocator_arg, ScopedAlloc{11, 22}, val);
+    Counter::reset();
+    return std::move(*src);
+  };
+
+  Polymorphic i1(make());
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i1 == *val );
+  VERIFY( i1->get_alloc_personality() == 22 );
+  VERIFY( i1.get_allocator().get_personality() == 11 );
+  verifyNoAllocations();
+
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{11, 22}, make());
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i2 == *val );
+  VERIFY( i2->get_alloc_personality() == 22 );
+  VERIFY( i2.get_allocator().get_personality() == 11 );
+  verifyNoAllocations();
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{33, 44}, make());
+  // We move-from contained object
+  VERIFY( !src->valueless_after_move() );
+  VERIFY( *i3 == *val );
+  VERIFY( i3->get_alloc_personality() == 44 );
+  VERIFY( i3.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() >= sizeof(Vector) );
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_construct_count() == 2 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_assign()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  const Polymorphic val(std::in_place_type<Vector>, {1, 2, 3});
+  std::optional<Polymorphic> src;
+  auto make = [&val, &src] -> Polymorphic&& {
+    src.emplace(std::allocator_arg, ScopedAlloc{11, 22}, val);
+    Counter::reset();
+    return std::move(*src);
+  };
+
+  Counter::reset();
+  Polymorphic i1(std::allocator_arg, ScopedAlloc{11, 22});
+  const std::size_t holderSize = Counter::get_allocation_count();
+  VERIFY( holderSize >= sizeof(Vector) );
+
+  i1 = make();
+  VERIFY( src->valueless_after_move() );
+  VERIFY( *i1 == *val );
+  VERIFY( i1->get_alloc_personality() == 22 );
+  VERIFY( i1.get_allocator().get_personality() == 11 );
+  VERIFY( Counter::get_allocation_count() == 0 );
+  VERIFY( Counter::get_deallocation_count() == holderSize );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{33, 44});
+
+  i2 = make();
+  VERIFY( *i2 == *val );
+  if (Propagate)
+  {
+    VERIFY( src->valueless_after_move() );
+    VERIFY( i2->get_alloc_personality() == 22 );
+    VERIFY( i2.get_allocator().get_personality() == 11 );
+    VERIFY( Counter::get_allocation_count() == 0 );
+    VERIFY( Counter::get_construct_count() == 0 );
+  }
+  else
+  {
+    // We allocate new holder and move-from contained object
+    VERIFY( !src->valueless_after_move() );
+    VERIFY( i2->get_alloc_personality() == 44 );
+    VERIFY( i2.get_allocator().get_personality() == 33 );
+    VERIFY( Counter::get_allocation_count() == holderSize );
+    VERIFY( Counter::get_construct_count() == 2 );
+  }
+  VERIFY( Counter::get_deallocation_count() == holderSize );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{11, 22},
+		 std::in_place_type<Vector>);
+  auto(std::move(i3));
+
+  i3 = make();
+  VERIFY( *i3 == *val );
+  VERIFY( src->valueless_after_move() );
+  VERIFY( i3->get_alloc_personality() == 22 );
+  VERIFY( i3.get_allocator().get_personality() == 11 );
+  verifyNoAllocations();
+
+  Polymorphic i4(std::allocator_arg, ScopedAlloc{33, 44},
+		 std::in_place_type<Vector>);
+  auto(std::move(i4));
+
+  i4 = make();
+  VERIFY( *i4 == *val );
+  if (Propagate)
+  {
+    VERIFY( src->valueless_after_move() );
+    VERIFY( i4->get_alloc_personality() == 22 );
+    VERIFY( i4.get_allocator().get_personality() == 11 );
+    VERIFY( Counter::get_allocation_count() == 0 );
+    VERIFY( Counter::get_construct_count() == 0 );
+  }
+  else
+  {
+    // We allocate new holder and move-from contained object
+    VERIFY( !src->valueless_after_move() );
+    VERIFY( i4->get_alloc_personality() == 44 );
+    VERIFY( i4.get_allocator().get_personality() == 33 );
+    VERIFY( Counter::get_allocation_count() == holderSize );
+    VERIFY( Counter::get_construct_count() == 2 );
+  }
+  VERIFY( Counter::get_deallocation_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 0 );
+}
+
+template<bool Propagate>
+constexpr void
+test_swap()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  const Polymorphic val1(std::in_place_type<Vector>, {1, 2, 3});
+  const Polymorphic val2(std::in_place_type<Vector>, {2, 4, 6});
+
+  Polymorphic i1(std::allocator_arg, ScopedAlloc{11, 22}, val1);
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{11, 22}, val2);
+  Counter::reset();
+  i1.swap(i2);
+  VERIFY( *i2 == *val1 );
+  VERIFY( *i1 == *val2 );
+  verifyNoAllocations();
+
+  auto(std::move(i1));
+
+  Counter::reset();
+  i1.swap(i2);
+  VERIFY( *i1 == *val1 );
+  VERIFY( i2.valueless_after_move() );
+  verifyNoAllocations();
+
+  if (!Propagate)
+    return;
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{33, 44}, val2);
+  Counter::reset();
+  i1.swap(i3);
+  VERIFY( *i1 == *val2 );
+  VERIFY( i1->get_alloc_personality() == 44 );
+  VERIFY( i1.get_allocator().get_personality() == 33 );
+  VERIFY( *i3 == *val1 );
+  VERIFY( i3->get_alloc_personality() == 22 );
+  VERIFY( i3.get_allocator().get_personality() == 11 );
+  verifyNoAllocations();
+
+  i1.swap(i2);
+  VERIFY( i1.valueless_after_move() );
+  VERIFY( i1.get_allocator().get_personality() == 11 );
+  VERIFY( *i2 == *val2 );
+  VERIFY( i2->get_alloc_personality() == 44 );
+  VERIFY( i2.get_allocator().get_personality() == 33 );
+  verifyNoAllocations();
+}
+
+template<bool Propagate>
+constexpr void
+test_valueless()
+{
+  using PropAlloc = propagating_allocator<int, Propagate>;
+  using Vector = VecDerived<int, PropAlloc>;
+  using ScopedAlloc = std::scoped_allocator_adaptor<
+    propagating_allocator<Vector, Propagate, tracker_allocator<Vector>>,
+    PropAlloc>;
+  using Polymorphic = std::polymorphic<Vector, ScopedAlloc>;
+
+  auto e = [] {
+    Polymorphic res(std::allocator_arg, ScopedAlloc{11, 22},
+		    std::in_place_type<Vector>);
+    auto(std::move(res));
+    Counter::reset();
+    return res;
+  };
+
+  Polymorphic i1(e());
+  VERIFY( i1.valueless_after_move() );
+  VERIFY( i1.get_allocator().get_personality() == 11 );
+  verifyNoAllocations();
+
+  Polymorphic i2(std::allocator_arg, ScopedAlloc{33, 44}, e());
+  VERIFY( i2.valueless_after_move() );
+  VERIFY( i2.get_allocator().get_personality() == 33 );
+  verifyNoAllocations();
+
+  Polymorphic i3(std::allocator_arg, ScopedAlloc{33, 44});
+
+  i3 = e();
+  VERIFY( i3.valueless_after_move() );
+  if (Propagate)
+    VERIFY( i3.get_allocator().get_personality() == 11 );
+  else
+    VERIFY( i3.get_allocator().get_personality() == 33 );
+  VERIFY( Counter::get_allocation_count() ==  0 );
+  VERIFY( Counter::get_deallocation_count() >= sizeof(Vector) );
+  VERIFY( Counter::get_construct_count() == 0 );
+  VERIFY( Counter::get_destruct_count() == 1 );
+
+  i2 = e();
+  VERIFY( i2.valueless_after_move() );
+  if (Propagate)
+    VERIFY( i2.get_allocator().get_personality() == 11 );
+  else
+    VERIFY( i2.get_allocator().get_personality() == 33 );
+  verifyNoAllocations();
+
+  i3.swap(i2);
+  VERIFY( i2.valueless_after_move() );
+  VERIFY( i1.valueless_after_move() );
+  verifyNoAllocations();
+
+  if (!Propagate)
+    return;
+
+  Polymorphic i4(std::allocator_arg, ScopedAlloc{33, 44}, e());
+  i4.swap(i1);
+  verifyNoAllocations();
+}
+
+template<bool Propagate>
+constexpr void
+test_all()
+{
+  test_ctor<Propagate>();
+  test_assign<Propagate>();
+  test_swap<Propagate>();
+  test_valueless<Propagate>();
+}
+
+int main()
+{
+  test_all<true>();
+  test_all<false>();
+
+  static_assert([] {
+    test_all<true>();
+    test_all<false>();
+    return true;
+  });
+}