Mark the parse callback in the new test noexcept

GCC's -Wnoexcept (part of the ci_test_gcc warning set) rejects the
lambda passed to parse() because it cannot throw but is not declared
noexcept, matching the existing callback in unit-regression2.cpp.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

include/nlohmann/detail/input/json_sax.hpp

@@ -18,6 +18,7 @@
 #include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/input/lexer.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 NLOHMANN_JSON_NAMESPACE_BEGIN
 
@@ -151,6 +152,29 @@ constexpr std::size_t unknown_size()
     return (std::numeric_limits<std::size_t>::max)();
 }
 
+/*!
+@brief reserve capacity for @a len elements in array @a arr
+
+Reserving upfront avoids repeated reallocations while the elements are added,
+but the reservation is capped so a bogus/hostile length (which is not bounded
+by max_size(), unlike e.g. std::vector) cannot trigger an oversized allocation
+for a small or truncated input.
+
+The overload below is selected for array types without reserve() (e.g.,
+std::deque), which are then left untouched.
+*/
+template<typename ArrayType>
+auto reserve_array(ArrayType& arr, std::size_t len, priority_tag<1> /*unused*/)
+-> decltype(arr.reserve(len), void())
+{
+    constexpr std::size_t reserve_cap = 16384;
+    arr.reserve((std::min)(len, reserve_cap));
+}
+
+template<typename ArrayType>
+inline void reserve_array(ArrayType& /*arr*/, std::size_t /*len*/, priority_tag<0> /*unused*/)
+{}
+
 /*!
 @brief SAX implementation to create a JSON value from SAX events
 
@@ -308,12 +332,7 @@ class json_sax_dom_parser
 
         if (len != detail::unknown_size())
         {
-            // reserve upfront to avoid repeated reallocations while adding elements,
-            // but cap the reservation so a bogus/hostile length (which is not bounded
-            // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-            // allocation for a small or truncated input
-            constexpr std::size_t reserve_cap = 16384;
-            ref_stack.back()->m_data.m_value.array->reserve((std::min)(len, reserve_cap));
+            reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
         }
 
         return true;
@@ -697,12 +716,7 @@ class json_sax_dom_callback_parser
 
             if (len != detail::unknown_size())
             {
-                // reserve upfront to avoid repeated reallocations while adding elements,
-                // but cap the reservation so a bogus/hostile length (which is not bounded
-                // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-                // allocation for a small or truncated input
-                constexpr std::size_t reserve_cap = 16384;
-                ref_stack.back()->m_data.m_value.array->reserve((std::min)(len, reserve_cap));
+                reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
             }
         }
 

single_include/nlohmann/json.hpp

@@ -10730,6 +10730,8 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/macro_scope.hpp>
 
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
 // #include <nlohmann/detail/string_concat.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -10864,6 +10866,29 @@ constexpr std::size_t unknown_size()
     return (std::numeric_limits<std::size_t>::max)();
 }
 
+/*!
+@brief reserve capacity for @a len elements in array @a arr
+
+Reserving upfront avoids repeated reallocations while the elements are added,
+but the reservation is capped so a bogus/hostile length (which is not bounded
+by max_size(), unlike e.g. std::vector) cannot trigger an oversized allocation
+for a small or truncated input.
+
+The overload below is selected for array types without reserve() (e.g.,
+std::deque), which are then left untouched.
+*/
+template<typename ArrayType>
+auto reserve_array(ArrayType& arr, std::size_t len, priority_tag<1> /*unused*/)
+-> decltype(arr.reserve(len), void())
+{
+    constexpr std::size_t reserve_cap = 16384;
+    arr.reserve((std::min)(len, reserve_cap));
+}
+
+template<typename ArrayType>
+inline void reserve_array(ArrayType& /*arr*/, std::size_t /*len*/, priority_tag<0> /*unused*/)
+{}
+
 /*!
 @brief SAX implementation to create a JSON value from SAX events
 
@@ -11021,12 +11046,7 @@ class json_sax_dom_parser
 
         if (len != detail::unknown_size())
         {
-            // reserve upfront to avoid repeated reallocations while adding elements,
-            // but cap the reservation so a bogus/hostile length (which is not bounded
-            // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-            // allocation for a small or truncated input
-            constexpr std::size_t reserve_cap = 16384;
-            ref_stack.back()->m_data.m_value.array->reserve((std::min)(len, reserve_cap));
+            reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
         }
 
         return true;
@@ -11410,12 +11430,7 @@ class json_sax_dom_callback_parser
 
             if (len != detail::unknown_size())
             {
-                // reserve upfront to avoid repeated reallocations while adding elements,
-                // but cap the reservation so a bogus/hostile length (which is not bounded
-                // by max_size(), unlike e.g. std::vector) cannot trigger an oversized
-                // allocation for a small or truncated input
-                constexpr std::size_t reserve_cap = 16384;
-                ref_stack.back()->m_data.m_value.array->reserve((std::min)(len, reserve_cap));
+                reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
             }
         }
 

tests/src/unit-regression3.cpp

@@ -27,6 +27,7 @@ using ordered_json = nlohmann::ordered_json;
 #endif
 
 #include <cstdio>
+#include <deque>
 #include <list>
 #include <type_traits>
 #include <utility>
@@ -896,4 +897,49 @@ TEST_CASE("issue #5402 - update(merge_objects=true) overwrites a primitive with
 }
 
 
+TEST_CASE("regression test #5476 - array type without reserve()")
+{
+    // the capacity reserved for definite-length arrays must not require the
+    // array type to have a reserve() member function
+    using deque_json = nlohmann::basic_json<std::map, std::deque>;
+
+    SECTION("std::deque")
+    {
+        const auto j = deque_json::parse(R"({"a":[1,[2,3]],"b":[]})");
+        CHECK(j.dump() == R"({"a":[1,[2,3]],"b":[]})");
+
+        // the binary formats pass a definite length to start_array()
+        CHECK(deque_json::from_cbor(deque_json::to_cbor(j)) == j);
+        CHECK(deque_json::from_msgpack(deque_json::to_msgpack(j)) == j);
+
+        // parse() instantiates the callback parser as well, which reserves too
+        const auto with_callback = deque_json::parse(R"([1,2,3])", [](int /*depth*/, deque_json::parse_event_t /*event*/, deque_json& /*parsed*/) noexcept
+        {
+            return true;
+        });
+        CHECK(with_callback == deque_json({1, 2, 3}));
+    }
+
+    SECTION("std::vector still reserves")
+    {
+        json array = json::array();
+        for (int i = 0; i < 100; ++i)
+        {
+            array.push_back(i);
+        }
+
+        const auto j = json::from_cbor(json::to_cbor(array));
+        CHECK(j == array);
+        CHECK(j.get_ref<const json::array_t&>().capacity() >= 100);
+    }
+
+    SECTION("the reservation stays capped")
+    {
+        // CBOR array announcing 2^32-1 elements, but truncated right after the
+        // header: the input must be rejected without reserving that capacity
+        const std::vector<std::uint8_t> truncated = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
+        CHECK(json::from_cbor(truncated, true, false).is_discarded());
+    }
+}
+
 DOCTEST_CLANG_SUPPRESS_WARNING_POP