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>

include/nlohmann/detail/conversions/to_json.hpp

@@ -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();
     }

include/nlohmann/json.hpp

@@ -1687,8 +1687,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)
             {
@@ -1710,8 +1710,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();
@@ -1724,8 +1724,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;
     }
 
@@ -1735,8 +1735,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;
     }
 
@@ -1746,8 +1746,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;
     }
 
@@ -1757,8 +1757,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;
     }
 
@@ -2815,8 +2815,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();
         }
 
@@ -2875,8 +2875,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();
         }
 
@@ -2928,8 +2928,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();
         }
 
@@ -3864,8 +3864,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();
         }
 
@@ -3897,8 +3897,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();
         }
 
@@ -3929,8 +3929,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();
         }
 
@@ -3985,8 +3985,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();
         }
 
@@ -4010,8 +4010,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();
         }
 
@@ -4192,8 +4192,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();
         }
 
@@ -5996,240 +5996,21 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     {
         // the patch
         basic_json result(value_t::array);
-        diff_recursively(result, source, target, path, 0);
-        return result;
-    }
 
-  private:
-    /// @brief two arrays or two objects @ref diff_iteratively is diffing
-    struct diff_frame
-    {
-        diff_frame(const basic_json* source_, const basic_json* target_, const std::size_t path_length_) noexcept
-            : source(source_), target(target_), path_length(path_length_)
-        {}
-
-        // declared for GCC's -Weffc++, which asks for them in a class with
-        // pointer members and a non-trivial destructor; the exception
-        // specifications are left implicit, as GCC 4.8 rejects explicit ones
-        // that differ from them
-        diff_frame(const diff_frame&) = default;
-        diff_frame(diff_frame&&) = default;
-        diff_frame& operator=(const diff_frame&) = default;
-        diff_frame& operator=(diff_frame&&) = default;
-        ~diff_frame() = default;
-
-        /// the values being diffed, both arrays or both objects
-        const basic_json* source;
-        const basic_json* target;
-        /// the length of their path in `current_path`
-        std::size_t path_length;
-        /// arrays: the next index to diff
-        std::size_t index = 0;
-        /// objects: the next member of source to look at
-        const_iterator member{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the keys common to both, in source's order
-        std::vector<typename object_t::key_type> common_keys{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the next entry of common_keys
-        std::size_t next_common = 0;
-        /// objects: the "add" operations for keys only target has
-        basic_json added_ops{}; // NOLINT(readability-redundant-member-init)
-    };
-
-    // The operations of a diff are built by the functions below rather than
-    // where they are needed: building one takes several temporaries, and
-    // unoptimized builds give each temporary a stack slot of its own in the
-    // function it appears in. In diff_recursively, which is on the call stack
-    // once per nesting level, that made every level cost kilobytes of stack.
-
-    /// @brief append a "replace" operation for @a path with @a value to @a result
-    static void diff_replace(basic_json& result, const string_t& path, const basic_json& value)
-    {
-        result.push_back(
-        {
-            {"op", "replace"}, {"path", path}, {"value", value}
-        });
-    }
-
-    /// @brief append a "remove" operation for @a path to @a result
-    static void diff_remove(basic_json& result, const string_t& path)
-    {
-        result.push_back(object(
-        {
-            {"op", "remove"}, {"path", path}
-        }));
-    }
-
-    /// @brief append an "add" operation for @a path with @a value to @a result
-    static void diff_add(basic_json& result, const string_t& path, const basic_json& value)
-    {
-        result.push_back(
-        {
-            {"op", "add"}, {"path", path}, {"value", value}
-        });
-    }
-
-    /// @brief append the "remove" operations for the elements of array
-    ///        @a source from @a index on, and the "add" operations for the
-    ///        elements of array @a target from source's size on, to @a result
-    static void diff_array_tails(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, const std::size_t index)
-    {
-        // remove my remaining elements, highest index first; appending
-        // in that order avoids the quadratic reinsertion done before
-        for (std::size_t j = source.size(); j > index; --j)
-        {
-            diff_remove(result, detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1)));
-        }
-
-        // add other remaining elements
-        for (std::size_t i = source.size(); i < target.size(); ++i)
-        {
-            diff_add(result, detail::concat<string_t>(path, "/-"), target[i]);
-        }
-    }
-
-    /*!
-    @brief compare the keys of objects @a source and @a target
-
-    If the keys both objects have are in the same order in both, and the keys
-    only @a target has come after them, stores the keys common to both in
-    source's order in @a common_keys, stores the "add" operations for the keys
-    only @a target has in @a added_ops, and returns true: the caller then diffs
-    the objects member by member. Otherwise, appends operations that remove
-    every member of @a source and add every member of @a target to @a result,
-    and returns false.
-    */
-    static bool diff_object_keys(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, std::vector<typename object_t::key_type>& common_keys,
-                                 basic_json& added_ops)
-    {
-        // first pass: record, for every source key, whether it is
-        // common to both objects (in source's iteration order) or
-        // was deleted (i.e., in source but not in target) -- this is
-        // a by-product of the target.find() call already needed to
-        // tell the two cases apart, so it adds no extra lookups. The
-        // "remove" ops themselves are emitted later, interleaved
-        // with the per-key diffs in the caller's fast path, to match
-        // source's original iteration order (as the original,
-        // pre-reordering-aware implementation did) instead of
-        // grouping all removes before all per-key diffs.
-        std::vector<typename object_t::key_type> common_keys_source_order;
-        for (auto it = source.cbegin(); it != source.cend(); ++it)
-        {
-            if (target.find(it.key()) != target.end())
-            {
-                common_keys_source_order.push_back(it.key());
-            }
-        }
-
-        // second pass: find keys that were added (i.e., in target but
-        // not in source), and record the keys common to both, in
-        // target's iteration order -- again a by-product of the
-        // source.find() call already needed to detect added keys. At
-        // the same time, determine whether every added key comes
-        // after every common key in target's order (a precondition
-        // for the fast path, which only ever appends new keys
-        // at the very end): for an object_t whose iteration order is
-        // a pure function of the key set (e.g. the default std::map,
-        // which always iterates in sorted key order), the order
-        // check further below is always true and this whole
-        // mechanism is effectively a no-op; it only matters for a
-        // reorderable object_t such as the one backing `ordered_json`.
-        // The patch ops for keys that were added (i.e., in target but not
-        // in source) are built here so the fast path can reuse
-        // them without a second source.find() per target key. Only
-        // used by the fast path -- the slow (reordering) path
-        // rebuilds "add" ops for every key itself.
-        std::vector<typename object_t::key_type> common_keys_target_order;
-        bool new_keys_form_suffix = true;
-        bool seen_new_key = false;
-        for (auto it = target.cbegin(); it != target.cend(); ++it)
-        {
-            if (source.find(it.key()) == source.end())
-            {
-                seen_new_key = true;
-                diff_add(added_ops, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-            }
-            else
-            {
-                common_keys_target_order.push_back(it.key());
-                if (seen_new_key)
-                {
-                    new_keys_form_suffix = false;
-                }
-            }
-        }
-
-        if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
-        {
-            // fast path: order of common keys already matches (or the
-            // object_t's iteration order does not depend on
-            // insertion history), so a plain per-key diff is correct
-            // and minimal, as before
-            common_keys = std::move(common_keys_source_order);
-            return true;
-        }
-
-        // slow path: the common keys are in a different relative
-        // order in source and target (only possible for a
-        // reorderable object_t like ordered_map). Building a
-        // minimal reordering patch is a nontrivial (LCS-like)
-        // problem; instead, remove every source key -- both
-        // deleted keys (which must be removed regardless) and
-        // common keys (removed so they can be re-added in
-        // target's order) -- and re-add every key that should
-        // remain, with its final target value, in target's
-        // order. basic_json::patch()'s "add" operation on an
-        // object uses operator[], which appends at the end for a
-        // vector-backed insertion-ordered map when the key does
-        // not already exist -- so removing a key and then adding
-        // it moves it to the end, fixing its position.
-        for (auto it = source.cbegin(); it != source.cend(); ++it)
-        {
-            diff_remove(result, detail::concat<string_t>(path, '/', detail::escape(it.key())));
-        }
-
-        // add every key that is either common (just removed
-        // above) or brand new, in target's iteration order, so
-        // that the final order after applying the patch matches
-        // target exactly
-        for (auto it = target.cbegin(); it != target.cend(); ++it)
-        {
-            diff_add(result, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-        }
-        return false;
-    }
-
-    /*!
-    @brief @ref diff, for values at nesting level @a depth, appending the
-           operations to @a result
-
-    Diffing two arrays or objects calls this function again, once per nesting
-    level, so values nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    diff_iteratively diffs what is left without the call stack.
-    */
-    static void diff_recursively(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, const std::size_t depth)
-    {
-        // if the values are the same, there is nothing to do
+        // if the values are the same, return an empty patch
         if (source == target)
         {
-            return;
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            diff_iteratively(result, source, target, path);
-            return;
+            return result;
         }
 
         if (source.type() != target.type())
         {
             // different types: replace value
-            diff_replace(result, path, target);
-            return;
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
         }
 
         switch (source.type())
@@ -6241,50 +6022,185 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 while (i < source.size() && i < target.size())
                 {
                     // recursive call to compare array values at index i
-                    diff_recursively(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
+                    auto temp_diff = diff(source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                     ++i;
                 }
 
                 // We now reached the end of at least one array
                 // in a second pass, traverse the remaining elements
-                diff_array_tails(result, source, target, path, i);
+
+                // remove my remaining elements, highest index first; appending
+                // in that order avoids the quadratic reinsertion done before
+                for (std::size_t j = source.size(); j > i; --j)
+                {
+                    result.push_back(object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1))}
+                    }));
+                }
+                i = source.size();
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat<string_t>(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
                 break;
             }
 
             case value_t::object:
             {
-                std::vector<typename object_t::key_type> common_keys;
-                basic_json added_ops(value_t::array);
-                if (diff_object_keys(result, source, target, path, common_keys, added_ops))
+                // first pass: record, for every source key, whether it is
+                // common to both objects (in source's iteration order) or
+                // was deleted (i.e., in source but not in target) -- this is
+                // a by-product of the target.find() call already needed to
+                // tell the two cases apart, so it adds no extra lookups. The
+                // "remove" ops themselves are emitted later, interleaved
+                // with the recursive per-key diffs in the fast path below,
+                // to match source's original iteration order (as the
+                // original, pre-reordering-aware implementation did) instead
+                // of grouping all removes before all recursive diffs.
+                std::vector<typename object_t::key_type> common_keys_source_order;
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
                 {
-                    // fast path: common_keys is, by construction, the
-                    // subsequence of source's keys that are common to both
-                    // objects, in source's iteration order -- so it can be
-                    // walked in lockstep with `source` using a cheap key
-                    // comparison instead of another lookup. Deleted keys
-                    // (those source keys not in common_keys) are interleaved
-                    // here too, in source's original order, to match the
-                    // historical (pre-reordering-aware) output order.
-                    auto common_it = common_keys.cbegin();
+                    if (target.find(it.key()) != target.end())
+                    {
+                        common_keys_source_order.push_back(it.key());
+                    }
+                }
+
+                // second pass: find keys that were added (i.e., in target but
+                // not in source), and record the keys common to both, in
+                // target's iteration order -- again a by-product of the
+                // source.find() call already needed to detect added keys. At
+                // the same time, determine whether every added key comes
+                // after every common key in target's order (a precondition
+                // for the fast path below, which only ever appends new keys
+                // at the very end): for an object_t whose iteration order is
+                // a pure function of the key set (e.g. the default std::map,
+                // which always iterates in sorted key order), the order
+                // check further below is always true and this whole
+                // mechanism is effectively a no-op; it only matters for a
+                // reorderable object_t such as the one backing `ordered_json`.
+                // patch ops for keys that were added (i.e., in target but not
+                // in source); built here so the fast path below can reuse
+                // them without a second source.find() per target key. Only
+                // used by the fast path -- the slow (reordering) path
+                // rebuilds "add" ops for every key itself.
+                std::vector<typename object_t::key_type> common_keys_target_order;
+                basic_json added_ops(value_t::array);
+                bool new_keys_form_suffix = true;
+                bool seen_new_key = false;
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        seen_new_key = true;
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        added_ops.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                    else
+                    {
+                        common_keys_target_order.push_back(it.key());
+                        if (seen_new_key)
+                        {
+                            new_keys_form_suffix = false;
+                        }
+                    }
+                }
+
+                if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
+                {
+                    // fast path: order of common keys already matches (or the
+                    // object_t's iteration order does not depend on
+                    // insertion history), so a plain per-key recursive diff
+                    // is correct and minimal, as before. common_keys_source_order
+                    // is, by construction, the subsequence of source's keys
+                    // that are common to both objects, in source's iteration
+                    // order -- so it can be walked in lockstep with `source`
+                    // using a cheap key comparison instead of another lookup.
+                    // Deleted keys (those source keys not in common_keys_source_order)
+                    // are interleaved here too, in source's original order, to
+                    // match the historical (pre-reordering-aware) output order.
+                    auto common_it = common_keys_source_order.cbegin();
                     for (auto it = source.cbegin(); it != source.cend(); ++it)
                     {
-                        if (common_it != common_keys.cend() && it.key() == *common_it)
+                        if (common_it != common_keys_source_order.cend() && it.key() == *common_it)
                         {
-                            diff_recursively(result, it.value(), target[it.key()], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
+                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                            auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                             ++common_it;
                         }
                         else
                         {
                             // found a key that is not in target -> remove it
-                            diff_remove(result, detail::concat<string_t>(path, '/', detail::escape(it.key())));
+                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                            result.push_back(object(
+                            {
+                                {"op", "remove"}, {"path", path_key}
+                            }));
                         }
                     }
 
-                    // append the "add" ops for brand-new keys collected by
-                    // diff_object_keys -- no second source.find() per target
-                    // key needed
+                    // append the "add" ops for brand-new keys collected above
+                    // during the pass over target -- no second source.find()
+                    // per target key needed
                     result.insert(result.end(), added_ops.begin(), added_ops.end());
                 }
+                else
+                {
+                    // slow path: the common keys are in a different relative
+                    // order in source and target (only possible for a
+                    // reorderable object_t like ordered_map). Building a
+                    // minimal reordering patch is a nontrivial (LCS-like)
+                    // problem; instead, remove every source key -- both
+                    // deleted keys (which must be removed regardless) and
+                    // common keys (removed so they can be re-added in
+                    // target's order) -- and re-add every key that should
+                    // remain, with its final target value, in target's
+                    // order. basic_json::patch()'s "add" operation on an
+                    // object uses operator[], which appends at the end for a
+                    // vector-backed insertion-ordered map when the key does
+                    // not already exist -- so removing a key and then adding
+                    // it moves it to the end, fixing its position.
+                    for (auto it = source.cbegin(); it != source.cend(); ++it)
+                    {
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+
+                    // add every key that is either common (just removed
+                    // above) or brand new, in target's iteration order, so
+                    // that the final order after applying the patch matches
+                    // target exactly
+                    for (auto it = target.cbegin(); it != target.cend(); ++it)
+                    {
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
                 break;
             }
 
@@ -6299,166 +6215,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             default:
             {
                 // both primitive types: replace value
-                diff_replace(result, path, target);
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
                 break;
             }
         }
+
+        return result;
     }
-
-    /*!
-    @brief @ref diff without the call stack, appending the operations to
-           @a result
-
-    Produces the same operations as @ref diff_recursively. Only reached for
-    values nested more deeply than @ref detail::recursion_depth_limit.
-    */
-    static void diff_iteratively(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path)
-    {
-        // The arrays and objects being diffed are kept on an explicit stack,
-        // and every pair of elements is still diffed completely before the
-        // next one, so the operations come out in the same order as in
-        // diff_recursively. The path of the values being diffed is kept in
-        // one buffer that grows and shrinks with the stack, rather than in a
-        // new string per level.
-        std::vector<diff_frame> stack;
-        string_t current_path = path;
-
-        // diff `s` against `t`, whose path is current_path: primitives,
-        // values of different types, and objects whose members were reordered
-        // are handled right away; arrays and other objects get a frame
-        const auto enter = [&result, &stack, &current_path](const basic_json & s, const basic_json & t)
-        {
-            // if the values are the same, there is nothing to do. Arrays and
-            // objects are not compared up front: comparing them visits
-            // everything below them, so doing that at every level would take
-            // quadratic time in the nesting depth - equal ones yield no
-            // operations anyway.
-            if ((!s.is_structured() || !t.is_structured()) && s == t)
-            {
-                return;
-            }
-
-            if (s.type() != t.type())
-            {
-                // different types: replace value
-                diff_replace(result, current_path, t);
-                return;
-            }
-
-            switch (s.type())
-            {
-                case value_t::array:
-                {
-                    stack.emplace_back(&s, &t, current_path.size());
-                    return;
-                }
-
-                case value_t::object:
-                {
-                    std::vector<typename object_t::key_type> common_keys;
-                    basic_json added_ops(value_t::array);
-                    if (diff_object_keys(result, s, t, current_path, common_keys, added_ops))
-                    {
-                        // fast path: the frame walks source in lockstep with
-                        // common_keys, as diff_recursively does, and appends
-                        // added_ops once all members are done
-                        stack.emplace_back(&s, &t, current_path.size());
-                        stack.back().member = s.cbegin();
-                        stack.back().common_keys = std::move(common_keys);
-                        stack.back().added_ops = std::move(added_ops);
-                    }
-                    return;
-                }
-
-                case value_t::null:
-                case value_t::string:
-                case value_t::boolean:
-                case value_t::number_integer:
-                case value_t::number_unsigned:
-                case value_t::number_float:
-                case value_t::binary:
-                case value_t::discarded:
-                default:
-                {
-                    // both primitive types: replace value
-                    diff_replace(result, current_path, t);
-                    return;
-                }
-            }
-        };
-
-        enter(source, target);
-        while (!stack.empty())
-        {
-            // invalidated when enter() pushes a frame and by the pop_back()
-            // at the end, so not used after either
-            diff_frame& frame = stack.back();
-            const std::size_t path_length = frame.path_length;
-            const std::size_t depth = stack.size();
-
-            if (frame.source->is_array())
-            {
-                const auto& source_array = *frame.source->m_data.m_value.array;
-                const auto& target_array = *frame.target->m_data.m_value.array;
-
-                // first pass: traverse common elements
-                if (frame.index < source_array.size() && frame.index < target_array.size())
-                {
-                    const std::size_t i = frame.index++;
-                    detail::concat_into(current_path, '/', detail::to_string<string_t>(i));
-                    enter(source_array[i], target_array[i]); // may push, which invalidates `frame`
-                    if (stack.size() == depth)
-                    {
-                        current_path.resize(path_length);
-                    }
-                    continue;
-                }
-
-                // We now reached the end of at least one array
-                // in a second pass, traverse the remaining elements
-                diff_array_tails(result, *frame.source, *frame.target, current_path, frame.index);
-            }
-            else
-            {
-                if (frame.member != frame.source->cend())
-                {
-                    const const_iterator it = frame.member;
-                    ++frame.member;
-                    if (frame.next_common < frame.common_keys.size() && it.key() == frame.common_keys[frame.next_common])
-                    {
-                        ++frame.next_common;
-                        const basic_json& target_value = (*frame.target)[it.key()];
-                        detail::concat_into(current_path, '/', detail::escape(it.key()));
-                        enter(it.value(), target_value); // may push, which invalidates `frame`
-                        if (stack.size() == depth)
-                        {
-                            current_path.resize(path_length);
-                        }
-                    }
-                    else
-                    {
-                        // found a key that is not in target -> remove it
-                        diff_remove(result, detail::concat<string_t>(current_path, '/', detail::escape(it.key())));
-                    }
-                    continue;
-                }
-
-                // append the "add" ops for brand-new keys collected when the
-                // object was entered
-                result.insert(result.end(), frame.added_ops.begin(), frame.added_ops.end());
-            }
-
-            // this array or object is done: continue with the one it is in
-            stack.pop_back();
-            if (!stack.empty())
-            {
-                current_path.resize(stack.back().path_length);
-            }
-        }
-    }
-
-  public:
     /// @}
 
     ////////////////////////////////

single_include/nlohmann/json.hpp

@@ -6571,6 +6571,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;
@@ -6594,18 +6598,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();
     }
 
@@ -6614,9 +6620,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();
     }
 };
@@ -6627,18 +6634,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();
     }
 };
@@ -6688,9 +6697,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();
     }
@@ -6698,9 +6708,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();
     }
@@ -6716,9 +6727,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();
     }
@@ -6726,15 +6738,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();
     }
 
@@ -6742,11 +6756,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();
     }
@@ -6758,14 +6773,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
@@ -6777,9 +6794,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();
     }
@@ -6787,9 +6805,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();
     }
@@ -6801,9 +6820,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();
     }
@@ -26645,8 +26665,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)
             {
@@ -26668,8 +26688,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();
@@ -26682,8 +26702,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;
     }
 
@@ -26693,8 +26713,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;
     }
 
@@ -26704,8 +26724,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;
     }
 
@@ -26715,8 +26735,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;
     }
 
@@ -27773,8 +27793,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();
         }
 
@@ -27833,8 +27853,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();
         }
 
@@ -27886,8 +27906,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();
         }
 
@@ -28822,8 +28842,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();
         }
 
@@ -28855,8 +28875,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();
         }
 
@@ -28887,8 +28907,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();
         }
 
@@ -28943,8 +28963,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();
         }
 
@@ -28968,8 +28988,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();
         }
 
@@ -29150,8 +29170,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();
         }
 
@@ -30954,240 +30974,21 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     {
         // the patch
         basic_json result(value_t::array);
-        diff_recursively(result, source, target, path, 0);
-        return result;
-    }
 
-  private:
-    /// @brief two arrays or two objects @ref diff_iteratively is diffing
-    struct diff_frame
-    {
-        diff_frame(const basic_json* source_, const basic_json* target_, const std::size_t path_length_) noexcept
-            : source(source_), target(target_), path_length(path_length_)
-        {}
-
-        // declared for GCC's -Weffc++, which asks for them in a class with
-        // pointer members and a non-trivial destructor; the exception
-        // specifications are left implicit, as GCC 4.8 rejects explicit ones
-        // that differ from them
-        diff_frame(const diff_frame&) = default;
-        diff_frame(diff_frame&&) = default;
-        diff_frame& operator=(const diff_frame&) = default;
-        diff_frame& operator=(diff_frame&&) = default;
-        ~diff_frame() = default;
-
-        /// the values being diffed, both arrays or both objects
-        const basic_json* source;
-        const basic_json* target;
-        /// the length of their path in `current_path`
-        std::size_t path_length;
-        /// arrays: the next index to diff
-        std::size_t index = 0;
-        /// objects: the next member of source to look at
-        const_iterator member{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the keys common to both, in source's order
-        std::vector<typename object_t::key_type> common_keys{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the next entry of common_keys
-        std::size_t next_common = 0;
-        /// objects: the "add" operations for keys only target has
-        basic_json added_ops{}; // NOLINT(readability-redundant-member-init)
-    };
-
-    // The operations of a diff are built by the functions below rather than
-    // where they are needed: building one takes several temporaries, and
-    // unoptimized builds give each temporary a stack slot of its own in the
-    // function it appears in. In diff_recursively, which is on the call stack
-    // once per nesting level, that made every level cost kilobytes of stack.
-
-    /// @brief append a "replace" operation for @a path with @a value to @a result
-    static void diff_replace(basic_json& result, const string_t& path, const basic_json& value)
-    {
-        result.push_back(
-        {
-            {"op", "replace"}, {"path", path}, {"value", value}
-        });
-    }
-
-    /// @brief append a "remove" operation for @a path to @a result
-    static void diff_remove(basic_json& result, const string_t& path)
-    {
-        result.push_back(object(
-        {
-            {"op", "remove"}, {"path", path}
-        }));
-    }
-
-    /// @brief append an "add" operation for @a path with @a value to @a result
-    static void diff_add(basic_json& result, const string_t& path, const basic_json& value)
-    {
-        result.push_back(
-        {
-            {"op", "add"}, {"path", path}, {"value", value}
-        });
-    }
-
-    /// @brief append the "remove" operations for the elements of array
-    ///        @a source from @a index on, and the "add" operations for the
-    ///        elements of array @a target from source's size on, to @a result
-    static void diff_array_tails(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, const std::size_t index)
-    {
-        // remove my remaining elements, highest index first; appending
-        // in that order avoids the quadratic reinsertion done before
-        for (std::size_t j = source.size(); j > index; --j)
-        {
-            diff_remove(result, detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1)));
-        }
-
-        // add other remaining elements
-        for (std::size_t i = source.size(); i < target.size(); ++i)
-        {
-            diff_add(result, detail::concat<string_t>(path, "/-"), target[i]);
-        }
-    }
-
-    /*!
-    @brief compare the keys of objects @a source and @a target
-
-    If the keys both objects have are in the same order in both, and the keys
-    only @a target has come after them, stores the keys common to both in
-    source's order in @a common_keys, stores the "add" operations for the keys
-    only @a target has in @a added_ops, and returns true: the caller then diffs
-    the objects member by member. Otherwise, appends operations that remove
-    every member of @a source and add every member of @a target to @a result,
-    and returns false.
-    */
-    static bool diff_object_keys(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, std::vector<typename object_t::key_type>& common_keys,
-                                 basic_json& added_ops)
-    {
-        // first pass: record, for every source key, whether it is
-        // common to both objects (in source's iteration order) or
-        // was deleted (i.e., in source but not in target) -- this is
-        // a by-product of the target.find() call already needed to
-        // tell the two cases apart, so it adds no extra lookups. The
-        // "remove" ops themselves are emitted later, interleaved
-        // with the per-key diffs in the caller's fast path, to match
-        // source's original iteration order (as the original,
-        // pre-reordering-aware implementation did) instead of
-        // grouping all removes before all per-key diffs.
-        std::vector<typename object_t::key_type> common_keys_source_order;
-        for (auto it = source.cbegin(); it != source.cend(); ++it)
-        {
-            if (target.find(it.key()) != target.end())
-            {
-                common_keys_source_order.push_back(it.key());
-            }
-        }
-
-        // second pass: find keys that were added (i.e., in target but
-        // not in source), and record the keys common to both, in
-        // target's iteration order -- again a by-product of the
-        // source.find() call already needed to detect added keys. At
-        // the same time, determine whether every added key comes
-        // after every common key in target's order (a precondition
-        // for the fast path, which only ever appends new keys
-        // at the very end): for an object_t whose iteration order is
-        // a pure function of the key set (e.g. the default std::map,
-        // which always iterates in sorted key order), the order
-        // check further below is always true and this whole
-        // mechanism is effectively a no-op; it only matters for a
-        // reorderable object_t such as the one backing `ordered_json`.
-        // The patch ops for keys that were added (i.e., in target but not
-        // in source) are built here so the fast path can reuse
-        // them without a second source.find() per target key. Only
-        // used by the fast path -- the slow (reordering) path
-        // rebuilds "add" ops for every key itself.
-        std::vector<typename object_t::key_type> common_keys_target_order;
-        bool new_keys_form_suffix = true;
-        bool seen_new_key = false;
-        for (auto it = target.cbegin(); it != target.cend(); ++it)
-        {
-            if (source.find(it.key()) == source.end())
-            {
-                seen_new_key = true;
-                diff_add(added_ops, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-            }
-            else
-            {
-                common_keys_target_order.push_back(it.key());
-                if (seen_new_key)
-                {
-                    new_keys_form_suffix = false;
-                }
-            }
-        }
-
-        if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
-        {
-            // fast path: order of common keys already matches (or the
-            // object_t's iteration order does not depend on
-            // insertion history), so a plain per-key diff is correct
-            // and minimal, as before
-            common_keys = std::move(common_keys_source_order);
-            return true;
-        }
-
-        // slow path: the common keys are in a different relative
-        // order in source and target (only possible for a
-        // reorderable object_t like ordered_map). Building a
-        // minimal reordering patch is a nontrivial (LCS-like)
-        // problem; instead, remove every source key -- both
-        // deleted keys (which must be removed regardless) and
-        // common keys (removed so they can be re-added in
-        // target's order) -- and re-add every key that should
-        // remain, with its final target value, in target's
-        // order. basic_json::patch()'s "add" operation on an
-        // object uses operator[], which appends at the end for a
-        // vector-backed insertion-ordered map when the key does
-        // not already exist -- so removing a key and then adding
-        // it moves it to the end, fixing its position.
-        for (auto it = source.cbegin(); it != source.cend(); ++it)
-        {
-            diff_remove(result, detail::concat<string_t>(path, '/', detail::escape(it.key())));
-        }
-
-        // add every key that is either common (just removed
-        // above) or brand new, in target's iteration order, so
-        // that the final order after applying the patch matches
-        // target exactly
-        for (auto it = target.cbegin(); it != target.cend(); ++it)
-        {
-            diff_add(result, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-        }
-        return false;
-    }
-
-    /*!
-    @brief @ref diff, for values at nesting level @a depth, appending the
-           operations to @a result
-
-    Diffing two arrays or objects calls this function again, once per nesting
-    level, so values nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    diff_iteratively diffs what is left without the call stack.
-    */
-    static void diff_recursively(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, const std::size_t depth)
-    {
-        // if the values are the same, there is nothing to do
+        // if the values are the same, return an empty patch
         if (source == target)
         {
-            return;
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            diff_iteratively(result, source, target, path);
-            return;
+            return result;
         }
 
         if (source.type() != target.type())
         {
             // different types: replace value
-            diff_replace(result, path, target);
-            return;
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
         }
 
         switch (source.type())
@@ -31199,50 +31000,185 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 while (i < source.size() && i < target.size())
                 {
                     // recursive call to compare array values at index i
-                    diff_recursively(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
+                    auto temp_diff = diff(source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                     ++i;
                 }
 
                 // We now reached the end of at least one array
                 // in a second pass, traverse the remaining elements
-                diff_array_tails(result, source, target, path, i);
+
+                // remove my remaining elements, highest index first; appending
+                // in that order avoids the quadratic reinsertion done before
+                for (std::size_t j = source.size(); j > i; --j)
+                {
+                    result.push_back(object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(j - 1))}
+                    }));
+                }
+                i = source.size();
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat<string_t>(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
                 break;
             }
 
             case value_t::object:
             {
-                std::vector<typename object_t::key_type> common_keys;
-                basic_json added_ops(value_t::array);
-                if (diff_object_keys(result, source, target, path, common_keys, added_ops))
+                // first pass: record, for every source key, whether it is
+                // common to both objects (in source's iteration order) or
+                // was deleted (i.e., in source but not in target) -- this is
+                // a by-product of the target.find() call already needed to
+                // tell the two cases apart, so it adds no extra lookups. The
+                // "remove" ops themselves are emitted later, interleaved
+                // with the recursive per-key diffs in the fast path below,
+                // to match source's original iteration order (as the
+                // original, pre-reordering-aware implementation did) instead
+                // of grouping all removes before all recursive diffs.
+                std::vector<typename object_t::key_type> common_keys_source_order;
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
                 {
-                    // fast path: common_keys is, by construction, the
-                    // subsequence of source's keys that are common to both
-                    // objects, in source's iteration order -- so it can be
-                    // walked in lockstep with `source` using a cheap key
-                    // comparison instead of another lookup. Deleted keys
-                    // (those source keys not in common_keys) are interleaved
-                    // here too, in source's original order, to match the
-                    // historical (pre-reordering-aware) output order.
-                    auto common_it = common_keys.cbegin();
+                    if (target.find(it.key()) != target.end())
+                    {
+                        common_keys_source_order.push_back(it.key());
+                    }
+                }
+
+                // second pass: find keys that were added (i.e., in target but
+                // not in source), and record the keys common to both, in
+                // target's iteration order -- again a by-product of the
+                // source.find() call already needed to detect added keys. At
+                // the same time, determine whether every added key comes
+                // after every common key in target's order (a precondition
+                // for the fast path below, which only ever appends new keys
+                // at the very end): for an object_t whose iteration order is
+                // a pure function of the key set (e.g. the default std::map,
+                // which always iterates in sorted key order), the order
+                // check further below is always true and this whole
+                // mechanism is effectively a no-op; it only matters for a
+                // reorderable object_t such as the one backing `ordered_json`.
+                // patch ops for keys that were added (i.e., in target but not
+                // in source); built here so the fast path below can reuse
+                // them without a second source.find() per target key. Only
+                // used by the fast path -- the slow (reordering) path
+                // rebuilds "add" ops for every key itself.
+                std::vector<typename object_t::key_type> common_keys_target_order;
+                basic_json added_ops(value_t::array);
+                bool new_keys_form_suffix = true;
+                bool seen_new_key = false;
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        seen_new_key = true;
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        added_ops.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                    else
+                    {
+                        common_keys_target_order.push_back(it.key());
+                        if (seen_new_key)
+                        {
+                            new_keys_form_suffix = false;
+                        }
+                    }
+                }
+
+                if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
+                {
+                    // fast path: order of common keys already matches (or the
+                    // object_t's iteration order does not depend on
+                    // insertion history), so a plain per-key recursive diff
+                    // is correct and minimal, as before. common_keys_source_order
+                    // is, by construction, the subsequence of source's keys
+                    // that are common to both objects, in source's iteration
+                    // order -- so it can be walked in lockstep with `source`
+                    // using a cheap key comparison instead of another lookup.
+                    // Deleted keys (those source keys not in common_keys_source_order)
+                    // are interleaved here too, in source's original order, to
+                    // match the historical (pre-reordering-aware) output order.
+                    auto common_it = common_keys_source_order.cbegin();
                     for (auto it = source.cbegin(); it != source.cend(); ++it)
                     {
-                        if (common_it != common_keys.cend() && it.key() == *common_it)
+                        if (common_it != common_keys_source_order.cend() && it.key() == *common_it)
                         {
-                            diff_recursively(result, it.value(), target[it.key()], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
+                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                            auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                             ++common_it;
                         }
                         else
                         {
                             // found a key that is not in target -> remove it
-                            diff_remove(result, detail::concat<string_t>(path, '/', detail::escape(it.key())));
+                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                            result.push_back(object(
+                            {
+                                {"op", "remove"}, {"path", path_key}
+                            }));
                         }
                     }
 
-                    // append the "add" ops for brand-new keys collected by
-                    // diff_object_keys -- no second source.find() per target
-                    // key needed
+                    // append the "add" ops for brand-new keys collected above
+                    // during the pass over target -- no second source.find()
+                    // per target key needed
                     result.insert(result.end(), added_ops.begin(), added_ops.end());
                 }
+                else
+                {
+                    // slow path: the common keys are in a different relative
+                    // order in source and target (only possible for a
+                    // reorderable object_t like ordered_map). Building a
+                    // minimal reordering patch is a nontrivial (LCS-like)
+                    // problem; instead, remove every source key -- both
+                    // deleted keys (which must be removed regardless) and
+                    // common keys (removed so they can be re-added in
+                    // target's order) -- and re-add every key that should
+                    // remain, with its final target value, in target's
+                    // order. basic_json::patch()'s "add" operation on an
+                    // object uses operator[], which appends at the end for a
+                    // vector-backed insertion-ordered map when the key does
+                    // not already exist -- so removing a key and then adding
+                    // it moves it to the end, fixing its position.
+                    for (auto it = source.cbegin(); it != source.cend(); ++it)
+                    {
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+
+                    // add every key that is either common (just removed
+                    // above) or brand new, in target's iteration order, so
+                    // that the final order after applying the patch matches
+                    // target exactly
+                    for (auto it = target.cbegin(); it != target.cend(); ++it)
+                    {
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
                 break;
             }
 
@@ -31257,166 +31193,16 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             default:
             {
                 // both primitive types: replace value
-                diff_replace(result, path, target);
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
                 break;
             }
         }
+
+        return result;
     }
-
-    /*!
-    @brief @ref diff without the call stack, appending the operations to
-           @a result
-
-    Produces the same operations as @ref diff_recursively. Only reached for
-    values nested more deeply than @ref detail::recursion_depth_limit.
-    */
-    static void diff_iteratively(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path)
-    {
-        // The arrays and objects being diffed are kept on an explicit stack,
-        // and every pair of elements is still diffed completely before the
-        // next one, so the operations come out in the same order as in
-        // diff_recursively. The path of the values being diffed is kept in
-        // one buffer that grows and shrinks with the stack, rather than in a
-        // new string per level.
-        std::vector<diff_frame> stack;
-        string_t current_path = path;
-
-        // diff `s` against `t`, whose path is current_path: primitives,
-        // values of different types, and objects whose members were reordered
-        // are handled right away; arrays and other objects get a frame
-        const auto enter = [&result, &stack, &current_path](const basic_json & s, const basic_json & t)
-        {
-            // if the values are the same, there is nothing to do. Arrays and
-            // objects are not compared up front: comparing them visits
-            // everything below them, so doing that at every level would take
-            // quadratic time in the nesting depth - equal ones yield no
-            // operations anyway.
-            if ((!s.is_structured() || !t.is_structured()) && s == t)
-            {
-                return;
-            }
-
-            if (s.type() != t.type())
-            {
-                // different types: replace value
-                diff_replace(result, current_path, t);
-                return;
-            }
-
-            switch (s.type())
-            {
-                case value_t::array:
-                {
-                    stack.emplace_back(&s, &t, current_path.size());
-                    return;
-                }
-
-                case value_t::object:
-                {
-                    std::vector<typename object_t::key_type> common_keys;
-                    basic_json added_ops(value_t::array);
-                    if (diff_object_keys(result, s, t, current_path, common_keys, added_ops))
-                    {
-                        // fast path: the frame walks source in lockstep with
-                        // common_keys, as diff_recursively does, and appends
-                        // added_ops once all members are done
-                        stack.emplace_back(&s, &t, current_path.size());
-                        stack.back().member = s.cbegin();
-                        stack.back().common_keys = std::move(common_keys);
-                        stack.back().added_ops = std::move(added_ops);
-                    }
-                    return;
-                }
-
-                case value_t::null:
-                case value_t::string:
-                case value_t::boolean:
-                case value_t::number_integer:
-                case value_t::number_unsigned:
-                case value_t::number_float:
-                case value_t::binary:
-                case value_t::discarded:
-                default:
-                {
-                    // both primitive types: replace value
-                    diff_replace(result, current_path, t);
-                    return;
-                }
-            }
-        };
-
-        enter(source, target);
-        while (!stack.empty())
-        {
-            // invalidated when enter() pushes a frame and by the pop_back()
-            // at the end, so not used after either
-            diff_frame& frame = stack.back();
-            const std::size_t path_length = frame.path_length;
-            const std::size_t depth = stack.size();
-
-            if (frame.source->is_array())
-            {
-                const auto& source_array = *frame.source->m_data.m_value.array;
-                const auto& target_array = *frame.target->m_data.m_value.array;
-
-                // first pass: traverse common elements
-                if (frame.index < source_array.size() && frame.index < target_array.size())
-                {
-                    const std::size_t i = frame.index++;
-                    detail::concat_into(current_path, '/', detail::to_string<string_t>(i));
-                    enter(source_array[i], target_array[i]); // may push, which invalidates `frame`
-                    if (stack.size() == depth)
-                    {
-                        current_path.resize(path_length);
-                    }
-                    continue;
-                }
-
-                // We now reached the end of at least one array
-                // in a second pass, traverse the remaining elements
-                diff_array_tails(result, *frame.source, *frame.target, current_path, frame.index);
-            }
-            else
-            {
-                if (frame.member != frame.source->cend())
-                {
-                    const const_iterator it = frame.member;
-                    ++frame.member;
-                    if (frame.next_common < frame.common_keys.size() && it.key() == frame.common_keys[frame.next_common])
-                    {
-                        ++frame.next_common;
-                        const basic_json& target_value = (*frame.target)[it.key()];
-                        detail::concat_into(current_path, '/', detail::escape(it.key()));
-                        enter(it.value(), target_value); // may push, which invalidates `frame`
-                        if (stack.size() == depth)
-                        {
-                            current_path.resize(path_length);
-                        }
-                    }
-                    else
-                    {
-                        // found a key that is not in target -> remove it
-                        diff_remove(result, detail::concat<string_t>(current_path, '/', detail::escape(it.key())));
-                    }
-                    continue;
-                }
-
-                // append the "add" ops for brand-new keys collected when the
-                // object was entered
-                result.insert(result.end(), frame.added_ops.begin(), frame.added_ops.end());
-            }
-
-            // this array or object is done: continue with the one it is in
-            stack.pop_back();
-            if (!stack.empty())
-            {
-                current_path.resize(stack.back().path_length);
-            }
-        }
-    }
-
-  public:
     /// @}
 
     ////////////////////////////////

tests/src/unit-allocator.cpp

@@ -388,3 +388,120 @@ 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;
+    }
+
+    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");
+
+        next_construct_fails = false;
+        nlohmann::to_json(j, std::vector<int> {1, 2});
+        CHECK(j == my_json({1, 2}));
+    }
+}
+#endif

tests/src/unit-json_patch.cpp

@@ -15,65 +15,8 @@ using nlohmann::json;
 #endif
 
 #include <fstream>
-#include <string>
-#include <vector>
 #include "make_test_data_available.hpp"
 
-namespace
-{
-// alternating objects and arrays nested `depth` levels deep, with members that
-// depend on `variant` at some levels, so diffing two variants yields
-// operations on many levels: replacing the innermost value, adding, removing,
-// and (for ordered_json) reordering members, and changing array lengths
-template<typename BasicJsonType>
-BasicJsonType nested(const std::size_t depth, const int variant)
-{
-    BasicJsonType value = variant;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (i % 2 == 0)
-        {
-            BasicJsonType object = BasicJsonType::object();
-            if ((i + static_cast<std::size_t>(variant)) % 7 == 0)
-            {
-                object["x"] = i;
-            }
-            if (variant == 2 && i % 11 == 0)
-            {
-                object["z"] = "z";
-            }
-            object["a"] = std::move(value);
-            if (variant == 1 && i % 5 == 0)
-            {
-                object["y"] = 1;
-            }
-            value = std::move(object);
-        }
-        else
-        {
-            BasicJsonType array = BasicJsonType::array({std::move(value)});
-            if ((i + static_cast<std::size_t>(variant)) % 3 == 0)
-            {
-                array.push_back(i);
-            }
-            value = std::move(array);
-        }
-    }
-    return value;
-}
-
-// a path of `depth` reference tokens, as nested() nests its values
-std::string nested_path(const std::size_t depth)
-{
-    std::string path;
-    for (std::size_t i = depth; i > 0; --i)
-    {
-        path += (i - 1) % 2 == 0 ? "/a" : "/0";
-    }
-    return path;
-}
-} // namespace
-
 TEST_CASE("JSON patch")
 {
     SECTION("examples from RFC 6902")
@@ -1808,99 +1751,3 @@ TEST_CASE("JSON patch - diff emits array removals in descending index order")
         CHECK(source.patch(patch) == target);
     }
 }
-
-TEST_CASE("JSON patch: diff of deeply nested values")
-{
-    SECTION("the diff reproduces the target at every depth")
-    {
-        // depths on either side of the nesting depth up to which diff()
-        // recurses (detail::recursion_depth_limit(), 128); not every depth up
-        // to 300, as the test would then time out under Valgrind
-        std::vector<std::size_t> depths;
-        for (std::size_t depth = 0; depth <= 16; ++depth)
-        {
-            depths.push_back(depth);
-        }
-        for (std::size_t depth = 120; depth <= 136; ++depth)
-        {
-            depths.push_back(depth);
-        }
-        depths.push_back(300);
-
-        for (const auto depth : depths)
-        {
-            CAPTURE(depth);
-            for (int from = 0; from < 3; ++from)
-            {
-                for (int to = 0; to < 3; ++to)
-                {
-                    CAPTURE(from);
-                    CAPTURE(to);
-                    const auto source = nested<json>(depth, from);
-                    const auto target = nested<json>(depth, to);
-                    const auto patch = json::diff(source, target);
-                    CHECK(source.patch(patch) == target);
-                    CHECK(patch.empty() == (from == to));
-
-                    const auto ordered_source = nested<nlohmann::ordered_json>(depth, from);
-                    const auto ordered_target = nested<nlohmann::ordered_json>(depth, to);
-                    CHECK(ordered_source.patch(nlohmann::ordered_json::diff(ordered_source, ordered_target)) == ordered_target);
-                }
-            }
-        }
-    }
-
-    SECTION("a difference only in the innermost value is one replace operation")
-    {
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            json source = 1;
-            json target = 2;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                source = i % 2 == 0 ? json::object({{"a", std::move(source)}}) : json::array({std::move(source)});
-                target = i % 2 == 0 ? json::object({{"a", std::move(target)}}) : json::array({std::move(target)});
-            }
-            CHECK(json::diff(source, target, "/root") == json::array({{{"op", "replace"}, {"path", "/root" + nested_path(depth)}, {"value", 2}}}));
-        }
-    }
-
-    SECTION("values nested too deeply for the call stack (#5393)")
-    {
-        // diff() used to recurse once per nesting level, and compared the
-        // values with operator== on every level. The values are only
-        // parsed and diffed, never copied or compared, since those recurse
-        // too.
-        const std::size_t depth = 100000;
-        for (const bool objects :
-                {
-                    false, true
-                })
-        {
-            CAPTURE(objects);
-            std::string source_text;
-            std::string target_text;
-            std::string equal_text;
-            std::string path;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                source_text += objects ? "{\"a\":" : "[";
-                path += objects ? "/a" : "/0";
-            }
-            target_text = source_text + "2";
-            equal_text = source_text + "1";
-            source_text += "1";
-            const std::string closing(depth, objects ? '}' : ']');
-            const auto source = json::parse(source_text + closing);
-
-            const auto patch = json::diff(source, json::parse(target_text + closing));
-            REQUIRE(patch.size() == 1);
-            CHECK(patch[0]["op"] == "replace");
-            CHECK(patch[0]["path"] == path);
-            CHECK(patch[0]["value"] == 2);
-
-            CHECK(json::diff(source, json::parse(equal_text + closing)).empty());
-        }
-    }
-}