Merge branch 'develop' into claude/fix-allocation-exception-safety

include/nlohmann/json.hpp conflicted in update(const_iterator, const_iterator, bool): kept develop's prepare_update() helper, which already creates the object before setting its type (the same fix this branch makes elsewhere). single_include/nlohmann/json.hpp was regenerated via `make amalgamate` instead of being hand-resolved. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Re-amalgamate single_include (#5745 )
2026-10-01 20:20:32 +00:00 · 2026-10-01 08:53:14 +02:00 · 2026-10-01 08:09:34 +02:00 · 2026-09-30 18:12:52 +02:00 · 2026-09-27 20:58:25 +02:00 · 2026-09-27 18:29:37 +02:00
6 changed files with 469 additions and 177 deletions
@@ -2,16 +2,23 @@ name: "Check amalgamation"

 on:
  pull_request:
+  # also check develop itself: a PR can be merged before its own run of this
+  # workflow completes (e.g. while it is still queued), leaving single_include
+  # stale on develop without any failing check
+  push:
+    branches:
+      - develop

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
-  cancel-in-progress: true
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

 permissions:
  contents: read

 jobs:
  save:
+    if: github.event_name == 'pull_request'
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
@@ -43,11 +50,11 @@ jobs:
        with:
          egress-policy: audit

-      - name: Checkout pull request
+      - name: Checkout pull request or pushed commit
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          path: main
-          ref: ${{ github.event.pull_request.head.sha }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
          persist-credentials: false

      - name: Checkout tools
@@ -10,7 +10,8 @@ permissions:

 jobs:
  comment:
-    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
+    # push runs on develop have no PR to comment on (and no "pr" artifact)
+    if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event == 'pull_request' }}
    runs-on: ubuntu-latest
    permissions:
      contents: read
@@ -42,6 +42,10 @@ namespace detail
 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
 * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
+ *
+ * A value that has to be allocated is created before the old one is destroyed:
+ * were it the other way around, an exception while creating the new value would
+ * leave j with the type of the new value, but the pointer to the destroyed old one.
 */

 template<value_t> struct external_constructor;
@@ -65,18 +69,20 @@ struct external_constructor<value_t::string>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
+        const typename BasicJsonType::json_value value(s);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = s;
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
+        const typename BasicJsonType::json_value value(std::move(s));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = std::move(s);
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

@@ -85,9 +91,10 @@ struct external_constructor<value_t::string>
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
+        auto* created = j.template create<typename BasicJsonType::string_t>(str);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.m_data.m_value.string = created;
        j.assert_invariant();
    }
 };
@@ -98,18 +105,20 @@ struct external_constructor<value_t::binary>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
+        const typename BasicJsonType::json_value value(b);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
+        const typename BasicJsonType::json_value value(std::move(b));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.m_data.m_value = value;
        j.assert_invariant();
    }
 };
@@ -159,9 +168,10 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
+        const typename BasicJsonType::json_value value(arr);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = arr;
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -169,9 +179,10 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
+        const typename BasicJsonType::json_value value(std::move(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = std::move(arr);
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -187,9 +198,10 @@ struct external_constructor<value_t::array>
        using std::begin;
        using std::end;

+        auto* created = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.m_data.m_value.array = created;
        j.set_parents();
        j.assert_invariant();
    }
@@ -197,15 +209,17 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
-        j.m_data.m_value.destroy(j.m_data.m_type);
-        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
-        j.m_data.m_value.array->reserve(arr.size());
+        typename BasicJsonType::array_t elements;
+        elements.reserve(arr.size());
        for (const bool x : arr)
        {
-            j.m_data.m_value.array->push_back(x);
-            j.set_parent(j.m_data.m_value.array->back());
+            elements.push_back(x);
        }
+        const typename BasicJsonType::json_value value(std::move(elements));
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value;
+        j.set_parents();
        j.assert_invariant();
    }

@@ -213,11 +227,12 @@ struct external_constructor<value_t::array>
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
+        typename BasicJsonType::array_t elements(arr.size());
+        std::copy(std::begin(arr), std::end(arr), elements.begin());
+        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
-        j.m_data.m_value.array->resize(arr.size());
-        std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -229,14 +244,16 @@ struct external_constructor<value_t::array>
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
-        j.m_data.m_value.destroy(j.m_data.m_type);
-        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
+        typename BasicJsonType::array_t elements;
        for (auto&& x : std::forward<CompatibleArrayType>(arr))
        {
-            j.m_data.m_value.array->push_back(x);
-            j.set_parent(j.m_data.m_value.array->back());
+            elements.push_back(x);
        }
+        const typename BasicJsonType::json_value value(std::move(elements));
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value;
+        j.set_parents();
        j.assert_invariant();
    }
 #endif
@@ -248,9 +265,10 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
+        const typename BasicJsonType::json_value value(obj);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = obj;
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -258,9 +276,10 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
+        const typename BasicJsonType::json_value value(std::move(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = std::move(obj);
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -272,9 +291,10 @@ struct external_constructor<value_t::object>
        using std::begin;
        using std::end;

+        auto* created = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.m_data.m_value.object = created;
        j.set_parents();
        j.assert_invariant();
    }
@@ -1894,8 +1894,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        if (is_an_object)
        {
            // the initializer list is a list of pairs -> create an object
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;

            for (auto& element_ref : init)
            {
@@ -1917,8 +1917,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            }
 #endif
            // the initializer list describes an array -> create an array
-            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+            m_data.m_type = value_t::array;
        }

        set_parents();
@@ -1931,8 +1931,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = init;
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -1942,8 +1942,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(init, subtype);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -1953,8 +1953,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = std::move(init);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -1964,8 +1964,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(std::move(init), subtype);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -3011,8 +3011,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>();
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -3078,8 +3078,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -3131,8 +3131,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -4082,8 +4082,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -4115,8 +4115,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -4147,8 +4147,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -4203,8 +4203,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -4228,8 +4228,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -18,16 +18,6 @@
 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
 #define INCLUDE_NLOHMANN_JSON_HPP_

-// Workaround for GCC template redefinition errors in C++ modules
-// When nlohmann/json.hpp is included in a C++20 module preamble after
-// other module imports, GCC may report spurious redefinition errors for
-// STL templates. These pragmas suppress those false positives.
-// See: https://github.com/nlohmann/json/issues/5103
-#if defined(__GNUC__) && !defined(__clang__) && __cplusplus >= 202002L
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-
 #include <algorithm> // all_of, find, for_each, none_of
 #include <cmath> // isnan
 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
@@ -2617,13 +2607,6 @@ JSON_HEDLEY_DIAGNOSTIC_POP
    #define JSON_NO_THREAD_LOCAL 1
 #endif

-// disable documentation warnings on clang
-#if defined(__clang__)
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wdocumentation"
-    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
-#endif
-
 // allow disabling exceptions
 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
    #define JSON_THROW(exception) throw exception
@@ -2682,7 +2665,7 @@ JSON_HEDLEY_DIAGNOSTIC_POP
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
@@ -2696,7 +2679,7 @@ JSON_HEDLEY_DIAGNOSTIC_POP
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
@@ -2735,7 +2718,7 @@ void templated_json_throw(ExceptionType exception)
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
@@ -2750,7 +2733,7 @@ void templated_json_throw(ExceptionType exception)
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
@@ -3578,8 +3561,7 @@ inline StringType escape(const StringType& s)

 /*!
 * @brief string unescaping as described in RFC 6901 (Sect. 4)
- * @param[in] s string to unescape
- * @return    unescaped string
+ * @param[in,out] s string to unescape in place
 *
 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
 *
@@ -5871,22 +5853,22 @@ void())
 }

 template < typename BasicJsonType, typename T, std::size_t... Idx >
-std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(const BasicJsonType& j,
                     identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
 {
-    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+    return { { j.at(Idx).template get<T>()... } };
 }

 template < typename BasicJsonType, typename T, std::size_t N >
-auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+auto from_json(const BasicJsonType& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(j, tag, make_index_sequence<N> {}))
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

-    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+    return from_json_inplace_array_impl(j, tag, make_index_sequence<N> {});
 }

 template<typename BasicJsonType>
@@ -6021,54 +6003,54 @@ template<std::size_t PTagValue, typename BasicJsonType, typename... Types>
 using tuple_type = std::tuple < decltype(from_json_tuple_get_impl(std::declval<BasicJsonType>(), detail::identity_tag<Types> {}, detail::priority_tag<PTagValue> {}))... >;

 template<std::size_t PTagValue, typename... Args, typename BasicJsonType, std::size_t... Idx>
-tuple_type<PTagValue, BasicJsonType, Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+tuple_type<PTagValue, const BasicJsonType&, Args...> from_json_tuple_impl_base(const BasicJsonType& j, index_sequence<Idx...> /*unused*/)
 {
-    return tuple_type<PTagValue, BasicJsonType, Args...>(from_json_tuple_get_impl(std::forward<BasicJsonType>(j).at(Idx), detail::identity_tag<Args> {}, detail::priority_tag<PTagValue> {})...);
+    return tuple_type<PTagValue, const BasicJsonType&, Args...>(from_json_tuple_get_impl(j.at(Idx), detail::identity_tag<Args> {}, detail::priority_tag<PTagValue> {})...);
 }

 template<std::size_t PTagValue, typename BasicJsonType>
-std::tuple<> from_json_tuple_impl_base(BasicJsonType& /*unused*/, index_sequence<> /*unused*/)
+std::tuple<> from_json_tuple_impl_base(const BasicJsonType& /*unused*/, index_sequence<> /*unused*/)
 {
    return {};
 }

 template < typename BasicJsonType, class A1, class A2 >
-std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+std::pair<A1, A2> from_json_tuple_impl(const BasicJsonType& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
 {
-    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
-            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+    return {j.at(0).template get<A1>(),
+            j.at(1).template get<A2>()};
 }

 template<typename BasicJsonType, typename A1, typename A2>
-inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+inline void from_json_tuple_impl(const BasicJsonType& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
 {
-    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+    p = from_json_tuple_impl(j, identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
 }

 template<typename BasicJsonType, typename... Args>
-std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+std::tuple<Args...> from_json_tuple_impl(const BasicJsonType& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
 {
-    static_assert(cxpr_and<cxpr_or<cxpr_not<std::is_reference<Args>>, is_compatible_reference_type<BasicJsonType, Args>>...>::value,
+    static_assert(cxpr_and<cxpr_or<cxpr_not<std::is_reference<Args>>, is_compatible_reference_type<const BasicJsonType&, Args>>...>::value,
                  "Can not return a tuple containing references to types not contained in a Json, try Json::get_to()");
-    return from_json_tuple_impl_base<1, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+    return from_json_tuple_impl_base<1, Args...>(j, index_sequence_for<Args...> {});
 }

 template<typename BasicJsonType, typename... Args>
-inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+inline void from_json_tuple_impl(const BasicJsonType& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
 {
-    t = from_json_tuple_impl_base<2, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+    t = from_json_tuple_impl_base<2, Args...>(j, index_sequence_for<Args...> {});
 }

 template<typename BasicJsonType, typename TupleRelated>
-auto from_json(BasicJsonType&& j, TupleRelated&& t)
-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+auto from_json(const BasicJsonType& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(j, std::forward<TupleRelated>(t), priority_tag<3> {}))
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
    {
        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
    }

-    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+    return from_json_tuple_impl(j, std::forward<TupleRelated>(t), priority_tag<3> {});
 }

 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
@@ -6153,7 +6135,7 @@ struct from_json_fn
 /// namespace to hold default `from_json` function
 /// to see why this is required:
 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces,misc-anonymous-namespace-in-header)
 {
 #endif
 JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
@@ -6629,11 +6611,11 @@ namespace std
    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
 #endif
 template<typename IteratorType>
-class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp,bugprone-std-namespace-modification)
    : public std::integral_constant<std::size_t, 2> {};

 template<std::size_t N, typename IteratorType>
-class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp,bugprone-std-namespace-modification)
 {
  public:
    using type = decltype(
@@ -6673,6 +6655,10 @@ namespace detail
 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
 * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
+ *
+ * A value that has to be allocated is created before the old one is destroyed:
+ * were it the other way around, an exception while creating the new value would
+ * leave j with the type of the new value, but the pointer to the destroyed old one.
 */

 template<value_t> struct external_constructor;
@@ -6696,18 +6682,20 @@ struct external_constructor<value_t::string>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
+        const typename BasicJsonType::json_value value(s);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = s;
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
+        const typename BasicJsonType::json_value value(std::move(s));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value = std::move(s);
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

@@ -6716,9 +6704,10 @@ struct external_constructor<value_t::string>
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
+        auto* created = j.template create<typename BasicJsonType::string_t>(str);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
-        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.m_data.m_value.string = created;
        j.assert_invariant();
    }
 };
@@ -6729,18 +6718,20 @@ struct external_constructor<value_t::binary>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
+        const typename BasicJsonType::json_value value(b);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.m_data.m_value = value;
        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
+        const typename BasicJsonType::json_value value(std::move(b));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::binary;
-        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.m_data.m_value = value;
        j.assert_invariant();
    }
 };
@@ -6790,9 +6781,10 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
+        const typename BasicJsonType::json_value value(arr);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = arr;
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6800,9 +6792,10 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
+        const typename BasicJsonType::json_value value(std::move(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = std::move(arr);
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6818,9 +6811,10 @@ struct external_constructor<value_t::array>
        using std::begin;
        using std::end;

+        auto* created = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.m_data.m_value.array = created;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6828,15 +6822,17 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
-        j.m_data.m_value.destroy(j.m_data.m_type);
-        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
-        j.m_data.m_value.array->reserve(arr.size());
+        typename BasicJsonType::array_t elements;
+        elements.reserve(arr.size());
        for (const bool x : arr)
        {
-            j.m_data.m_value.array->push_back(x);
-            j.set_parent(j.m_data.m_value.array->back());
+            elements.push_back(x);
        }
+        const typename BasicJsonType::json_value value(std::move(elements));
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value;
+        j.set_parents();
        j.assert_invariant();
    }

@@ -6844,11 +6840,12 @@ struct external_constructor<value_t::array>
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
+        typename BasicJsonType::array_t elements(arr.size());
+        std::copy(std::begin(arr), std::end(arr), elements.begin());
+        const typename BasicJsonType::json_value value(std::move(elements));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
-        j.m_data.m_value.array->resize(arr.size());
-        std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6860,14 +6857,16 @@ struct external_constructor<value_t::array>
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
-        j.m_data.m_value.destroy(j.m_data.m_type);
-        j.m_data.m_type = value_t::array;
-        j.m_data.m_value = value_t::array;
+        typename BasicJsonType::array_t elements;
        for (auto&& x : std::forward<CompatibleArrayType>(arr))
        {
-            j.m_data.m_value.array->push_back(x);
-            j.set_parent(j.m_data.m_value.array->back());
+            elements.push_back(x);
        }
+        const typename BasicJsonType::json_value value(std::move(elements));
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value;
+        j.set_parents();
        j.assert_invariant();
    }
 #endif
@@ -6879,9 +6878,10 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
+        const typename BasicJsonType::json_value value(obj);
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = obj;
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6889,9 +6889,10 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
+        const typename BasicJsonType::json_value value(std::move(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value = std::move(obj);
+        j.m_data.m_value = value;
        j.set_parents();
        j.assert_invariant();
    }
@@ -6903,9 +6904,10 @@ struct external_constructor<value_t::object>
        using std::begin;
        using std::end;

+        auto* created = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::object;
-        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.m_data.m_value.object = created;
        j.set_parents();
        j.assert_invariant();
    }
@@ -7178,7 +7180,7 @@ struct to_json_fn
 /// namespace to hold default `to_json` function
 /// to see why this is required:
 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces,misc-anonymous-namespace-in-header)
 {
 #endif
 JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
@@ -8399,6 +8401,9 @@ struct container_input_adapter_factory< ContainerType,

           static adapter_type create(ContainerType&& container)
 {
+    // container is forwarded twice on purpose: the resulting begin/end
+    // iterator types must match adapter_type, computed the same way
+    // NOLINTNEXTLINE(bugprone-use-after-move)
    return input_adapter(begin(std::forward<ContainerType>(container)), end(std::forward<ContainerType>(container)));
 }
       };
@@ -10298,9 +10303,9 @@ class lexer : public lexer_base<BasicJsonType>
    /////////////////////

    /*!
-    @brief get codepoint from 4 hex characters following `\u`
+    @brief get codepoint from 4 hex characters following `\\u`

-    For input "\u c1 c2 c3 c4" the codepoint is:
+    For input "\\u c1 c2 c3 c4" the codepoint is:
      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)

@@ -13949,7 +13954,7 @@ class binary_reader
    @brief Parses a C-style string from the BSON input.
    @param[in,out] result  A reference to the string variable where the read
                            string is to be stored.
-    @return `true` if the \x00-byte indicating the end of the string was
+    @return `true` if the \\x00-byte indicating the end of the string was
             encountered before the EOF; false` indicates an unexpected EOF.
    */
    bool get_bson_cstr(string_t& result)
@@ -13979,7 +13984,7 @@ class binary_reader
    @brief read a C-style string from contiguous input in one step

    @param[in,out] result  the string to append to
-    @return whether the string was read; if the input has no \x00-byte, nothing
+    @return whether the string was read; if the input has no \\x00-byte, nothing
            is read, and @ref get_bson_cstr reports the end of the input
    */
    bool get_bson_cstr_bulk(string_t& result, std::true_type /*bulk*/)
@@ -18636,7 +18641,7 @@ This class implements a both iterators (iterator and const_iterator) for the
      been set (e.g., by a constructor or a copy assignment). If the iterator is
      default-constructed, it is *uninitialized* and most methods are undefined.
      **The library uses assertions to detect calls on uninitialized iterators.**
-@requirement REQ-JSON-01 The class satisfies the following concept requirements:
+This class satisfies the following concept requirements (REQ-JSON-01):
 -
 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
  The iterator that can be moved can be moved in both directions (i.e.
@@ -19400,7 +19405,7 @@ namespace detail
 iterator (to create @ref reverse_iterator) and @ref const_iterator (to
 create @ref const_reverse_iterator).

-@requirement REQ-JSON-02 The class satisfies the following concept requirements:
+This class satisfies the following concept requirements (REQ-JSON-02):
 -
 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
  The iterator that can be moved can be moved in both directions (i.e.
@@ -19843,11 +19848,11 @@ class json_pointer
            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
        }

-        // only triggered on special platforms (like 32bit), see also
-        // https://github.com/nlohmann/json/pull/2203
+        // the index does not fit into size_type; on 64-bit platforms this is
+        // only SIZE_MAX itself (see #2203 and #5395)
        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
        {
-            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));
        }

        return static_cast<size_type>(res);
@@ -19881,7 +19886,7 @@ class json_pointer
    /*!
    @brief create and return a reference to the pointed to value

-    @complexity Linear in the number of reference tokens.
+    Complexity: Linear in the number of reference tokens.

    @throw parse_error.106 if an array index begins with '0'
    @throw parse_error.109 if array index is not a number
@@ -19968,7 +19973,7 @@ class json_pointer

    @return reference to the JSON value pointed to by the JSON pointer

-    @complexity Linear in the length of the JSON pointer.
+    Complexity: Linear in the length of the JSON pointer.

    @throw parse_error.106   if an array index begins with '0'
    @throw parse_error.109   if an array index was not a number
@@ -20880,6 +20885,7 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <cstddef> // size_t
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
+#include <type_traits> // conditional, integral_constant, is_same
 #include <utility> // move
 #include <vector> // vector

@@ -20988,11 +20994,13 @@ class output_stream_adapter : public output_adapter_protocol<CharType>
        : stream(s)
    {}

+    // NOLINTNEXTLINE(portability-template-virtual-member-function)
    void write_character(CharType c) override
    {
        stream.put(c);
    }

+    // NOLINTNEXTLINE(portability-template-virtual-member-function)
    void write_characters(const CharType* s, std::size_t length) override
    {
        stream.write(s, static_cast<std::streamsize>(length));
@@ -21059,7 +21067,82 @@ class output_adapter_sink
    output_adapter_t<CharType> oa;
 };

-template<typename CharType, typename StringType = std::basic_string<CharType>>
+/// @brief whether std::basic_string<CharType> has a non-deprecated std::char_traits
+///        specialization, and is therefore usable as output_adapter's default StringType
+///
+/// std::char_traits is only guaranteed (and, on some standard libraries, only
+/// implemented without a deprecation warning) for the character types listed
+/// below; std::char_traits<T> for any other T (e.g. std::uint8_t, as used by the
+/// binary writers) is a non-standard extension some standard libraries deprecate.
+/// See https://github.com/nlohmann/json/issues/5725 item 2.
+template<typename CharType>
+struct is_output_adapter_string_char_type : std::integral_constant < bool,
+    std::is_same<CharType, char>::value ||
+    std::is_same<CharType, wchar_t>::value ||
+    std::is_same<CharType, char16_t>::value ||
+    std::is_same<CharType, char32_t>::value
+#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201907L)
+    || std::is_same<CharType, char8_t>::value
+#endif
+    > {};
+
+/// @brief placeholder type for output_adapter's StringType and (with JSON_NO_IO
+///        undefined) its std::basic_ostream constructor parameter, for CharType
+///        with no non-deprecated std::char_traits specialization
+///
+/// Never actually used: the StringType- and std::basic_ostream-based
+/// output_adapter constructors are neither documented nor tested for such
+/// CharType (only the std::vector-based constructor is used for them, by the
+/// binary writers). Naming std::basic_string<CharType> or
+/// std::basic_ostream<CharType> anywhere such a constructor would otherwise be
+/// declared - even as an unused default template argument or an unused,
+/// never-called overload - instantiates std::char_traits<CharType> merely to
+/// name the type, which is exactly what triggers the deprecation warning this
+/// placeholder avoids.
+template<typename CharType>
+struct output_adapter_no_string_type {};
+
+// Select output_adapter's default StringType (and, below, its ostream
+// constructor's parameter type) via partial specialization, not
+// std::conditional: std::conditional<B, T, F> requires both T and F to be named
+// as template arguments up front, which would still instantiate (and thus name)
+// std::basic_string<CharType> / std::basic_ostream<CharType> for every CharType,
+// defeating the point. A bool non-type parameter with two specializations only
+// ever names the type that is actually selected.
+template<typename CharType, bool = is_output_adapter_string_char_type<CharType>::value>
+struct output_adapter_default_string_type
+{
+    using type = output_adapter_no_string_type<CharType>;
+};
+
+template<typename CharType>
+struct output_adapter_default_string_type<CharType, true>
+{
+    using type = std::basic_string<CharType>;
+};
+
+#ifndef JSON_NO_IO
+/// distinct from output_adapter_no_string_type, so the placeholder overloads of
+/// output_adapter's constructor (used when CharType is not a character type)
+/// stay distinct overloads instead of colliding into a single redeclaration
+template<typename CharType>
+struct output_adapter_no_ostream_type {};
+
+template<typename CharType, bool = is_output_adapter_string_char_type<CharType>::value>
+struct output_adapter_ostream_type
+{
+    using type = output_adapter_no_ostream_type<CharType>;
+};
+
+template<typename CharType>
+struct output_adapter_ostream_type<CharType, true>
+{
+    using type = std::basic_ostream<CharType>;
+};
+#endif  // JSON_NO_IO
+
+template < typename CharType, typename StringType =
+           typename output_adapter_default_string_type<CharType>::type >
 class output_adapter
 {
  public:
@@ -21068,7 +21151,7 @@ class output_adapter
        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}

 #ifndef JSON_NO_IO
-    output_adapter(std::basic_ostream<CharType>& s)
+    output_adapter(typename output_adapter_ostream_type<CharType>::type& s)
        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
 #endif  // JSON_NO_IO

@@ -24727,7 +24810,7 @@ class serializer
    @param[in] ichar  indentation character to use
    @param[in] pretty_print_  whether the output shall be pretty-printed
    @param[in] ensure_ascii_ If @a ensure_ascii_ is true, all non-ASCII
-    characters in the output are escaped with `\uXXXX` sequences, and the
+    characters in the output are escaped with `\\uXXXX` sequences, and the
    result consists of ASCII characters only.
    @param[in] indent_step_  the indent level
    @param[in] error_handler_  how to react on decoding errors
@@ -25352,7 +25435,7 @@ class serializer

    @param[in] s  the string to escape

-    @complexity Linear in the length of string @a s.
+    Complexity: Linear in the length of string @a s.
    */
    void dump_escaped(const string_t& s)
    {
@@ -25856,7 +25939,7 @@ class serializer
    }

    /*!
-     * @brief write a lowercase "\uXXXX" escape sequence into @a string_buffer
+     * @brief write a lowercase "\\uXXXX" escape sequence into @a string_buffer
     *
     * Branch-free replacement for `snprintf(buf, 7, "\\u%04x", codeunit)` in the
     * string escaping hot path. It writes exactly six characters ('\\', 'u' and
@@ -26206,7 +26289,7 @@ class serializer
    /// whether to pretty-print the output
    const bool pretty_print;

-    /// whether to escape non-ASCII characters with \uXXXX sequences
+    /// whether to escape non-ASCII characters with \\uXXXX sequences
    const bool ensure_ascii;

    /// the indent level
@@ -28509,8 +28592,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        if (is_an_object)
        {
            // the initializer list is a list of pairs -> create an object
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;

            for (auto& element_ref : init)
            {
@@ -28532,8 +28615,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            }
 #endif
            // the initializer list describes an array -> create an array
-            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+            m_data.m_type = value_t::array;
        }

        set_parents();
@@ -28546,8 +28629,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = init;
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -28557,8 +28640,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(init, subtype);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -28568,8 +28651,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = std::move(init);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -28579,8 +28662,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
    {
        auto res = basic_json();
-        res.m_data.m_type = value_t::binary;
        res.m_data.m_value = binary_t(std::move(init), subtype);
+        res.m_data.m_type = value_t::binary;
        return res;
    }

@@ -29156,12 +29239,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    @throw what @ref json_serializer<ValueType> `from_json()` method throws

-    @liveexample{The example below shows several conversions from JSON values
+    The example below shows several conversions from JSON values
    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,get__ValueType_const}
+    be converted to integers, (2) A JSON array can be converted to a standard
+    `std::vector<short>`, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string,
+    json>`.

    @since version 2.1.0
    */
@@ -29228,7 +29311,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    @return a copy of *this, converted into @a BasicJsonType

-    @complexity Depending on the implementation of the called `from_json()`
+    Complexity: Depending on the implementation of the called `from_json()`
                method.

    @since version 3.2.0
@@ -29252,7 +29335,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

    @return a copy of *this

-    @complexity Constant.
+    Complexity: Constant.

    @since version 2.1.0
    */
@@ -29298,7 +29381,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    @tparam ValueTypeCV the provided value type
    @tparam ValueType the returned value type

-    @return copy of the JSON value, converted to @tparam ValueType if necessary
+    @return copy of the JSON value, converted to @a ValueType if necessary

    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required

@@ -29336,12 +29419,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    @return pointer to the internally stored JSON value if the requested
    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise

-    @complexity Constant.
+    Complexity: Constant.

-    @liveexample{The example below shows how pointers to internal values of a
+    The example below shows how pointers to internal values of a
    JSON value can be requested. Note that no type conversions are made and a
    `nullptr` is returned if the value and the requested pointer type does not
-    match.,get__PointerType}
+    match.

    @sa see @ref get_ptr() for explicit pointer-member access

@@ -29435,14 +29518,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    to the JSON value type (e.g., the JSON value is of type boolean, but a
    string is requested); see example below

-    @complexity Linear in the size of the JSON value.
+    Complexity: Linear in the size of the JSON value.

-    @liveexample{The example below shows several conversions from JSON values
+    The example below shows several conversions from JSON values
    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,operator__ValueType}
+    be converted to integers, (2) A JSON array can be converted to a standard
+    `std::vector<short>`, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string,
+    json>`.

    @since version 1.0.0
    */
@@ -29626,8 +29709,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value.array = create<array_t>();
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -29693,8 +29776,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -29746,8 +29829,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // implicitly convert a null value to an empty object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -30697,8 +30780,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -30730,8 +30813,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -30762,8 +30845,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -30818,8 +30901,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an array
        if (is_null())
        {
-            m_data.m_type = value_t::array;
            m_data.m_value = value_t::array;
+            m_data.m_type = value_t::array;
            assert_invariant();
        }

@@ -30843,8 +30926,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // transform a null object into an object
        if (is_null())
        {
-            m_data.m_type = value_t::object;
            m_data.m_value = value_t::object;
+            m_data.m_type = value_t::object;
            assert_invariant();
        }

@@ -31897,6 +31980,19 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
    ///             version 4.0.0 of the library. Please use
    ///             sax_parse(ptr, ptr + len) instead.
+    //
+    // Clang reports "declaration is marked with '@deprecated' command but does
+    // not have a deprecation attribute" for this overload even though
+    // JSON_HEDLEY_DEPRECATED_FOR below does expand to __attribute__((deprecated));
+    // isolated reproductions of this exact declaration shape (doc comment,
+    // template<>, two stacked __attribute__ lines, an overload set of the same
+    // name) do not reproduce it, so this looks like a Clang comment/declaration
+    // association quirk specific to this overload within basic_json, not a
+    // genuine documentation bug. See #5725 item 2.
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync"
+#endif
    template <typename SAX>
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
    JSON_HEDLEY_NON_NULL(2)
@@ -31913,6 +32009,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
    }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
 #ifndef JSON_NO_IO
    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
@@ -33575,7 +33674,7 @@ namespace std // NOLINT(cert-dcl58-cpp)
 /// @brief hash value for JSON objects
 /// @sa https://json.nlohmann.me/api/basic_json/std_hash/
 NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp,bugprone-std-namespace-modification)
 {
    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
    {
@@ -33608,7 +33707,7 @@ struct less< ::nlohmann::detail::value_t> // do not remove the space after '<',
 /// @brief exchanges the values of two JSON objects
 /// @sa https://json.nlohmann.me/api/basic_json/std_swap/
 NLOHMANN_BASIC_JSON_TPL_DECLARATION
-inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp,bugprone-std-namespace-modification)
    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
 {
@@ -33622,7 +33721,7 @@ inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC
 /// @brief std::formatter specialization for JSON values
 /// @sa https://json.nlohmann.me/api/basic_json/std_formatter/
 NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-cpp)
+struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-cpp,bugprone-std-namespace-modification)
 {
    // -1 means compact output (dump()); any value >= 0 means pretty-printed
    // output with that many spaces (or indent_char) per level (dump(indent, indent_char)).
@@ -33711,11 +33810,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c



-// restore clang diagnostic settings
-#if defined(__clang__)
-    #pragma clang diagnostic pop
-#endif
-
 // clean up
 #undef JSON_ASSERT
 #undef JSON_INTERNAL_CATCH
@@ -33916,11 +34010,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c

 // IWYU pragma: keep

-// End of GCC diagnostic pragmas for C++ modules support
-#if defined(__GNUC__) && !defined(__clang__) && __cplusplus >= 202002L
-    #pragma GCC diagnostic pop
-#endif
-
 // The user-defined string literals are in a separate header, because their
 // bodies instantiate the parser in every translation unit that includes them.
 // Define JSON_NO_AUTOMATIC_UDLS to include <nlohmann/json_literals.hpp> only
@@ -12,6 +12,11 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

+#include <valarray>
+#if JSON_HAS_RANGES
+    #include <ranges>
+#endif
+
 namespace
 {
 // special test case to check if memory is leaked if constructor throws
@@ -592,3 +597,173 @@ TEST_CASE("bad my_allocator::construct")
        j["test"].push_back("should not leak");
    }
 }
+
+// the no-exceptions CI job skips every CHECK_THROWS_AS, which would leave
+// next_construct_fails set for the next allocation outside a check
+#if !defined(JSON_NOEXCEPTION)
+TEST_CASE("a failed allocation leaves the value unchanged")
+{
+    // create JSON type using the throwing allocator
+    using my_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          my_allocator>;
+
+    // Each of these creates a string, array, object, or binary value. The
+    // value must be created before the type is changed: otherwise, a failed
+    // creation left a value of the new type without anything behind it (an
+    // assertion in its destructor, a null pointer everywhere else) or, when
+    // an old value was destroyed first, with a pointer to that destroyed one.
+
+    SECTION("creating a binary value")
+    {
+        const std::vector<std::uint8_t> bytes = {1, 2, 3};
+        my_json _;
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(_ = my_json::binary(bytes), std::bad_alloc&);
+        next_construct_fails = true;
+        CHECK_THROWS_AS(_ = my_json::binary(bytes, 42), std::bad_alloc&);
+        next_construct_fails = true;
+        CHECK_THROWS_AS(_ = my_json::binary(std::vector<std::uint8_t>(bytes)), std::bad_alloc&);
+        next_construct_fails = true;
+        CHECK_THROWS_AS(_ = my_json::binary(std::vector<std::uint8_t>(bytes), 42), std::bad_alloc&);
+        next_construct_fails = false;
+    }
+
+    SECTION("turning a null value into an array or object")
+    {
+        my_json j;
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j[0], std::bad_alloc&);
+        CHECK(j.is_null());
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j["key"], std::bad_alloc&);
+        CHECK(j.is_null());
+
+#ifdef JSON_HAS_CPP_17
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j[std::string_view("key")], std::bad_alloc&);
+        CHECK(j.is_null());
+#endif
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.push_back(my_json(1)), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        const my_json one = 1;
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.push_back(one), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.push_back(my_json::object_t::value_type("key", 1)), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.emplace_back(1), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.emplace("key", 1), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        const my_json object = {{"key", 1}};
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j.update(object), std::bad_alloc&);
+        CHECK(j.is_null());
+
+        next_construct_fails = false;
+    }
+
+    // With iterator debugging, VS 2015's containers construct a proxy with the
+    // allocator in constructors that cannot report its failure, so a failing
+    // allocator crashes this section there (SIGSEGV with VS 2015 Debug x86).
+#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
+    SECTION("converting into an existing value")
+    {
+        // to_json replaces the value it is given; the old one must survive a
+        // failed creation of the new one
+        my_json j = "old";
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::string("new")), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::vector<int> {1, 2}), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::vector<bool> {true, false}), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::map<std::string, int> {{"a", 1}}), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, my_json::binary_t({1, 2})), std::bad_alloc&);
+        CHECK(j == "old");
+
+        // the overloads for lvalues of the value types, for the value types
+        // themselves, and for the remaining compatible types
+        const std::string string = "new";
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, string), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, "new"), std::bad_alloc&);
+        CHECK(j == "old");
+
+        // to_json only moves a binary value that it converted from another
+        // container type, which my_json's std::vector<std::uint8_t> is not
+        using binary_constructor = nlohmann::detail::external_constructor<nlohmann::detail::value_t::binary>;
+        next_construct_fails = true;
+        CHECK_THROWS_AS(binary_constructor::construct(j, my_json::binary_t({1, 2})), std::bad_alloc&);
+        CHECK(j == "old");
+
+        my_json::array_t array = {1, 2};
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, array), std::bad_alloc&);
+        CHECK(j == "old");
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::move(array)), std::bad_alloc&);
+        CHECK(j == "old");
+
+        my_json::object_t object = {{"a", 1}};
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, object), std::bad_alloc&);
+        CHECK(j == "old");
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::move(object)), std::bad_alloc&);
+        CHECK(j == "old");
+
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, std::valarray<int> {1, 2}), std::bad_alloc&);
+        CHECK(j == "old");
+
+#if JSON_HAS_RANGES && !defined(__MINGW32__)
+        const std::vector<int> numbers = {1, 2};
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, numbers | std::views::filter([](int /*unused*/)
+        {
+            return true;
+        })), std::bad_alloc&);
+        CHECK(j == "old");
+#endif
+
+        next_construct_fails = false;
+        nlohmann::to_json(j, std::vector<int> {1, 2});
+        CHECK(j == my_json({1, 2}));
+    }
+#endif
+}
+#endif
Author	SHA1	Message	Date
Niels Lohmann	362a902170	Merge branch 'develop' into claude/fix-allocation-exception-safety include/nlohmann/json.hpp conflicted in update(const_iterator, const_iterator, bool): kept develop's prepare_update() helper, which already creates the object before setting its type (the same fix this branch makes elsewhere). single_include/nlohmann/json.hpp was regenerated via `make amalgamate` instead of being hand-resolved. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 08:53:14 +02:00
Niels Lohmann	e400780533	Re-amalgamate single_include (#5745 ) * Re-amalgamate single_include #5737 changed 13 headers under include/ but merged without the matching single_include/nlohmann/json.hpp update, so the amalgamated header still had, among others, the GCC C++20 -Wignored-attributes pragma block and the clang -Wdocumentation push/pop that #5737 removed, the forwarding from_json tuple/array helpers it replaced with const references, and lacked the output_adapter char_traits changes it added. Regenerated with `make amalgamate` (astyle 3.4.13). The diff is exactly `git diff `b54ed188e` `e5a89d671` -- include/` (164+/95-); json_fwd.hpp and json_literals.hpp were already up to date. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Run the amalgamation check on pushes to develop #5737 was merged 39 seconds after its last push, while its own check_amalgamation run was still queued (earlier runs had been cancelled by the concurrency group), so the stale single_include reached develop without any failing check. Also run the check on pushes to develop, without cancelling in-progress develop runs. The "save" job (PR number/author for the comment workflow) only runs for pull requests, the checkout falls back to github.sha, and comment_check_amalgamation.yml only comments for PR-triggered runs, since push runs have no PR and no "pr" artifact. Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 08:09:34 +02:00
Niels Lohmann	ba6bf32f6d	Skip the to_json allocation-failure section on VS 2015 Debug AppVeyor's VS 2015 Debug x86 job crashed (SIGSEGV) in "a failed allocation leaves the value unchanged / converting into an existing value". With iterator debugging, VS 2015's containers construct a proxy with the allocator in constructors that cannot report its failure, so the throwing test allocator crashes there. The existing guard covered only the std::vector<bool> check; skip the whole section on that toolchain instead. The Release builds and all other compilers still run it. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 18:12:52 +02:00
Niels Lohmann	056d187986	Merge branch 'develop' into claude/fix-allocation-exception-safety Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 20:58:25 +02:00
Niels Lohmann	90078597c7	Test the remaining to_json overloads with a failing allocation The test only reached 5 of the 14 external_constructor overloads that were reordered: reverting the fix in any of the other 9 (const string_t&, compatible strings, binary_t&&, array_t const&/&&, std::valarray, ranges views, object_t const&/&&) left it green. Each of them is now called with a failing allocation, and reverting any single hunk of the fix makes the test fail under ASan. binary_t&& is only reached by to_json for a binary container type other than std::vector<std::uint8_t>, so the test calls the constructor directly. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 18:29:37 +02:00
Niels Lohmann	fa28fff7d6	Skip the vector<bool> failed-allocation check for VS 2015 with iterator debugging AppVeyor's VS 2015 Debug build terminated in "converting into an existing value": to_json for std::vector<bool> default-constructs an array_t first, and VS 2015's std::vector default constructor is noexcept but, with iterator debugging, constructs its proxy through the test's allocator, which throws. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 13:30:57 +02:00
Niels Lohmann	e9c84befa1	Keep the created pointer rather than an uninitialized json_value clang-tidy reported the json_value unions declared in the string, array, and object constructors of to_json.hpp as uninitialized (cppcoreguidelines-pro-type-member-init). Assign the created pointer to the member directly once the old value is destroyed. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-26 10:07:22 +02:00
Niels Lohmann	8a26f2dc8f	Skip the failed-allocation test when exceptions are disabled The no-exceptions CI job runs doctest with --no-throw, which skips every CHECK_THROWS_AS. The test then left next_construct_fails set, and the next allocation outside a check threw std::bad_alloc. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-26 07:41:42 +02:00
Niels Lohmann	2c108d0b56	Create a value before giving it its type Several functions set the type of a value before creating the string, array, object, or binary value it stands for. When that creation threw - std::bad_alloc from the allocator, say - the value was left behind with the new type but nothing behind it: - json::binary() returned no value, but its destructor asserted that a binary value has a binary array, aborting debug builds. - operator[], push_back, emplace_back, emplace, and update turned a null value into an array or object that did not exist; any later access dereferenced a null pointer. - The to_json conversions destroyed the old value first. A failed creation of the new one left a pointer to the destroyed old value, which was then used and freed again (heap-use-after-free). The value is now created first and the type set after it, and to_json destroys the old value only once the new one exists, so a failed allocation leaves the value unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-25 22:19:39 +02:00