multimap.cons excep move_alloc and move_assign

Author: vinay-deshmukh

libcxx/include/__tree

@@ -1121,20 +1121,22 @@ public:
       return;
 
     if (__root() == nullptr) { // Make sure we always have a root node
-      __insert_node_at(
-          __end_node(), __end_node()->__left_, static_cast<__node_base_pointer>(__construct_node(*__first).release()));
+      __insert_node_at(__end_node(),
+                       __end_node()->__left_,
+                       std::__static_fancy_pointer_cast<__node_base_pointer>(__construct_node(*__first).release()));
       ++__first;
     }
 
-    auto __max_node = static_cast<__node_pointer>(std::__tree_max(static_cast<__node_base_pointer>(__root())));
+    auto __max_node = std::__static_fancy_pointer_cast<__node_pointer>(
+        std::__tree_max(std::__static_fancy_pointer_cast<__node_base_pointer>(__root())));
 
     for (; __first != __last; ++__first) {
       __node_holder __nd = __construct_node(*__first);
       // Always check the max node first. This optimizes for sorted ranges inserted at the end.
       if (!value_comp()(__nd->__get_value(), __max_node->__get_value())) { // __node >= __max_val
-        __insert_node_at(static_cast<__end_node_pointer>(__max_node),
+        __insert_node_at(std::__static_fancy_pointer_cast<__end_node_pointer>(__max_node),
                          __max_node->__right_,
-                         static_cast<__node_base_pointer>(__nd.get()));
+                         std::__static_fancy_pointer_cast<__node_base_pointer>(__nd.get()));
         __max_node = __nd.release();
       } else {
         __end_node_pointer __parent;
@@ -1899,7 +1901,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent
         }
       } else {
         if (__nd->__right_ != nullptr)
-          __nd = static_cast<__node_pointer>(__nd->__right_);
+          __nd = std::__static_fancy_pointer_cast<__node_pointer>(__nd->__right_);
         else {
           __parent = std::__static_fancy_pointer_cast<__end_node_pointer>(__nd);
           return __nd->__right_;
@@ -2062,8 +2064,8 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {
   __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
   __end_node_pointer __parent;
   __node_base_pointer& __child = __find_leaf_high(__parent, __h->__get_value());
-  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-  return iterator(static_cast<__node_pointer>(__h.release()));
+  __insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__h.get()));
+  return iterator(std::__static_fancy_pointer_cast<__node_pointer>(__h.release()));
 }
 
 template <class _Tp, class _Compare, class _Allocator>

libcxx/test/std/containers/associative/multimap/multimap.cons/copy.pass.cpp

@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <template <class> class Alloc>
-void test_alloc() {
+TEST_CONSTEXPR_CXX26 void test_alloc() {
   { // Simple check
     using V   = std::pair<const int, int>;
     using Map = std::multimap<int, int, std::less<int>, Alloc<V> >;

libcxx/test/std/containers/associative/multimap/multimap.cons/copy_alloc.pass.cpp

@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class Alloc>
-void test_alloc(const Alloc& new_alloc) {
+TEST_CONSTEXPR_CXX26 void test_alloc(const Alloc& new_alloc) {
   { // Simple check
     using V   = std::pair<const int, int>;
     using Map = std::multimap<int, int, std::less<int>, Alloc>;

libcxx/test/std/containers/associative/multimap/multimap.cons/copy_assign.pass.cpp

@@ -33,41 +33,48 @@ class tracking_allocator {
   using value_type                             = T;
   using propagate_on_container_copy_assignment = std::true_type;
 
+  TEST_CONSTEXPR_CXX26
   tracking_allocator(std::vector<void*>& allocs) : allocs_(&allocs) {}
 
   template <class U>
-  tracking_allocator(const tracking_allocator<U>& other) : allocs_(other.allocs_) {}
+  TEST_CONSTEXPR_CXX26 tracking_allocator(const tracking_allocator<U>& other) : allocs_(other.allocs_) {}
 
+  TEST_CONSTEXPR_CXX26
   T* allocate(std::size_t n) {
     T* allocation = std::allocator<T>().allocate(n);
     allocs_->push_back(allocation);
     return allocation;
   }
 
+  TEST_CONSTEXPR_CXX26
   void deallocate(T* ptr, std::size_t n) TEST_NOEXCEPT {
     auto res = std::remove(allocs_->begin(), allocs_->end(), ptr);
     assert(res != allocs_->end() && "Trying to deallocate memory from different allocator?");
     allocs_->erase(res);
     std::allocator<T>().deallocate(ptr, n);
   }
 
+  TEST_CONSTEXPR_CXX26
   friend bool operator==(const tracking_allocator& lhs, const tracking_allocator& rhs) {
     return lhs.allocs_ == rhs.allocs_;
   }
 
+  TEST_CONSTEXPR_CXX26
   friend bool operator!=(const tracking_allocator& lhs, const tracking_allocator& rhs) {
     return lhs.allocs_ != rhs.allocs_;
   }
 };
 
 struct NoOp {
+  TEST_CONSTEXPR_CXX26
   void operator()() {}
 };
 
 template <class Alloc, class AllocatorInvariant = NoOp>
-void test_alloc(const Alloc& lhs_alloc                   = Alloc(),
-                const Alloc& rhs_alloc                   = Alloc(),
-                AllocatorInvariant check_alloc_invariant = NoOp()) {
+TEST_CONSTEXPR_CXX26 void
+test_alloc(const Alloc& lhs_alloc                   = Alloc(),
+           const Alloc& rhs_alloc                   = Alloc(),
+           AllocatorInvariant check_alloc_invariant = NoOp()) {
   {   // Test empty/non-empty multimap combinations
     { // assign from a non-empty container into an empty one
       using V   = std::pair<const int, int>;
@@ -258,9 +265,11 @@ bool test() {
       std::vector<void*>* rhs_allocs_;
 
     public:
+      TEST_CONSTEXPR_CXX26
       AssertEmpty(std::vector<void*>& lhs_allocs, std::vector<void*>& rhs_allocs)
           : lhs_allocs_(&lhs_allocs), rhs_allocs_(&rhs_allocs) {}
 
+      TEST_CONSTEXPR_CXX26
       void operator()() {
         assert(lhs_allocs_->empty());
         assert(rhs_allocs_->empty());

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct.pass.cpp

@@ -215,8 +215,6 @@ bool test() {
 
   AssociativeContainerDeductionGuidesSfinaeAway<std::multimap, std::multimap<int, long>>();
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {

libcxx/test/std/containers/associative/multimap/multimap.cons/deduct_const.pass.cpp

@@ -104,8 +104,6 @@ bool test() {
     assert(m.get_allocator().get_id() == 45);
   }
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {

libcxx/test/std/containers/associative/multimap/multimap.cons/default.pass.cpp

@@ -52,8 +52,6 @@ bool test() {
   }
 #endif
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {

libcxx/test/std/containers/associative/multimap/multimap.cons/default_noexcept.pass.cpp

@@ -54,8 +54,6 @@ bool test() {
     static_assert(!std::is_nothrow_default_constructible<C>::value, "");
   }
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {

libcxx/test/std/containers/associative/multimap/multimap.cons/from_range.pass.cpp

@@ -44,8 +44,6 @@ bool test() {
   test_map_exception_safety_throwing_copy<std::multimap>();
   test_map_exception_safety_throwing_allocator<std::multimap, int, int>();
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp

@@ -57,8 +57,6 @@ bool test() {
     assert(*++i == V(3, 2));
   }
 
-  return 0;
-
   return true;
 }
 int main(int, char**) {