add constexpr for insert_node_type and insert_node_type_hint

Author: vinay-deshmukh

libcxx/include/__tree

@@ -2132,9 +2132,10 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __n
   __node_pointer __ptr = __nh.__ptr_;
   auto [__parent, __child] = __find_equal(__ptr->__get_value());
   if (__child != nullptr)
-    return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};
+    return _InsertReturnType{
+        iterator(std::__static_fancy_pointer_cast<__node_pointer>(__child)), false, std::move(__nh)};
 
-  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+  __insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__ptr));
   __nh.__release_ptr();
   return _InsertReturnType{iterator(__ptr), true, _NodeHandle()};
 }
@@ -2151,7 +2152,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __
   auto [__parent, __child] = __find_equal(__hint, __dummy, __ptr->__get_value());
   __node_pointer __r       = static_cast<__node_pointer>(__child);
   if (__child == nullptr) {
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+    __insert_node_at(__parent, __child, std::__static_fancy_pointer_cast<__node_base_pointer>(__ptr));
     __r = __ptr;
     __nh.__release_ptr();
   }

libcxx/test/std/containers/associative/map/map.modifiers/insert_node_type.pass.cpp

@@ -12,7 +12,7 @@
 
 // class map
 
-// insert_return_type insert(node_type&&);
+// constexpr insert_return_type insert(node_type&&); // constexpr since C++26
 
 #include <map>
 #include <memory>
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class Container, class T>
-void verify_insert_return_type(T&& t) {
+TEST_CONSTEXPR_CXX26 void verify_insert_return_type(T&& t) {
   using verified_type = std::remove_cv_t<std::remove_reference_t<T>>;
   static_assert(std::is_aggregate_v<verified_type>);
   static_assert(std::is_same_v<verified_type, typename Container::insert_return_type>);
@@ -42,20 +42,20 @@ void verify_insert_return_type(T&& t) {
 }
 
 template <class Container>
-typename Container::node_type
+TEST_CONSTEXPR_CXX26 std::pair<Container, typename Container::node_type>
 node_factory(typename Container::key_type const& key, typename Container::mapped_type const& mapped) {
-  static Container c;
+  Container c;
   auto p = c.insert({key, mapped});
   assert(p.second);
-  return c.extract(p.first);
+  return {c, c.extract(p.first)};
 }
 
 template <class Container>
-TEST_CONSTEXPR_CXX26 bool test(Container& c) {
+TEST_CONSTEXPR_CXX26 void testContainer(Container& c) {
   auto* nf = &node_factory<Container>;
 
   for (int i = 0; i != 10; ++i) {
-    typename Container::node_type node = nf(i, i + 1);
+    auto [/*Container*/ staticContainer, /*typename Container::node_type*/ node] = nf(i, i + 1);
     assert(!node.empty());
     typename Container::insert_return_type irt = c.insert(std::move(node));
     assert(node.empty());
@@ -78,13 +78,14 @@ TEST_CONSTEXPR_CXX26 bool test(Container& c) {
   }
 
   { // Insert duplicate node.
-    typename Container::node_type dupl = nf(0, 42);
+    auto [/*Container*/ staticContainer, /*typename Container::node_type*/ dupl] = nf(0, 42);
     auto irt                           = c.insert(std::move(dupl));
     assert(dupl.empty());
     assert(!irt.inserted);
     assert(!irt.node.empty());
     assert(irt.position == c.find(0));
-    assert(irt.node.key() == 0 && irt.node.mapped() == 42);
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      assert(irt.node.key() == 0 && irt.node.mapped() == 42);
     verify_insert_return_type<Container>(irt);
   }
 
@@ -94,24 +95,21 @@ TEST_CONSTEXPR_CXX26 bool test(Container& c) {
     assert(c.count(i) == 1);
     assert(c[i] == i + 1);
   }
+}
+
+TEST_CONSTEXPR_CXX26
+bool test() {
+  std::map<int, int> m;
+  testContainer(m);
+  std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
+  testContainer(m2);
   return true;
 }
 
 int main(int, char**) {
-  {
-    std::map<int, int> m;
-    test(m);
-    std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
-    test(m2);
-  }
-
+  test();
 #if TEST_STD_VER >= 26
-  {
-    std::map<int, int> m;
-    test(m);
-    std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
-    test(m2);
-  }
+  static_assert(test());
 #endif
 
   return 0;

libcxx/test/std/containers/associative/map/map.modifiers/insert_node_type_hint.pass.cpp

@@ -19,20 +19,20 @@
 #include "min_allocator.h"
 
 template <class Container>
-typename Container::node_type
+TEST_CONSTEXPR_CXX26 std::pair<Container, typename Container::node_type>
 node_factory(typename Container::key_type const& key, typename Container::mapped_type const& mapped) {
-  static Container c;
+  Container c;
   auto p = c.insert({key, mapped});
   assert(p.second);
-  return c.extract(p.first);
+  return {c, c.extract(p.first)};
 }
 
 template <class Container>
-void test(Container& c) {
+TEST_CONSTEXPR_CXX26 void test(Container& c) {
   auto* nf = &node_factory<Container>;
 
   for (int i = 0; i != 10; ++i) {
-    typename Container::node_type node = nf(i, i + 1);
+    auto [/*Container*/ staticContainer, /*typename Container::node_type*/ node] = nf(i, i + 1);
     assert(!node.empty());
     std::size_t prev = c.size();
     auto it          = c.insert(c.end(), std::move(node));
@@ -50,11 +50,21 @@ void test(Container& c) {
   }
 }
 
-int main(int, char**) {
+TEST_CONSTEXPR_CXX26
+bool test() {
   std::map<int, int> m;
   test(m);
   std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>> m2;
   test(m2);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+#if TEST_STD_VER >= 26
+  static_assert(test());
+#endif
 
   return 0;
 }