Merge branch 'develop' into claude/3453-breaking-change-flags-c937b4

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

.clang-tidy

@@ -1,9 +1,11 @@
-# TODO: portability-template-virtual-member-function is only removed to get the CI going. It has to be addressed at some point.
+# TODO: The first three checks are only removed to get the CI going. They have to be addressed at some point.
 # TODO: portability-avoid-pragma-once: should be fixed eventually
 
 Checks: '*,
 
          -portability-template-virtual-member-function,
+         -bugprone-use-after-move,
+         -hicpp-invalid-access-moved,
 
          -altera-id-dependent-backward-branch,
          -altera-struct-pack-align,

docs/mkdocs/docs/api/basic_json/meta.md

@@ -13,7 +13,7 @@ JSON object holding version information
 
 | key         | description                                                                                                                                                                                                                                                                    |
 |-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `hp`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version). |
+| `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version). On HP aCC compilers, `compiler` is instead the plain string `hp`. |
 | `copyright` | The copyright line for the library as string.                                                                                                                                                                                                                                  |
 | `name`      | The name of the library as string.                                                                                                                                                                                                                                             |
 | `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.                                                                                                                                                                             |

docs/mkdocs/docs/api/macros/json_brace_init_copy_semantics.md

@@ -115,3 +115,4 @@ The default value is `0` (disabled — existing behavior is preserved).
 ## Version history
 
 - Added in version 3.13.0.
+- Planned to become the default (with the macro removed) in version 4.0.0.

docs/mkdocs/docs/community/roadmap.md

@@ -14,7 +14,7 @@ work items are tracked in the [GitHub milestones](https://github.com/nlohmann/js
   opt-in.
 - **Keep the 3.x public API stable.** Releases follow [semantic versioning](https://semver.org). Changes that would
   break existing code are only added behind a feature macro, so users can opt in and test their code before a next
-  major release.
+  major release, see [Version 4.0](#version-40).
 - **Support a broad range of compilers and platforms.** The [CI](quality_assurance.md) keeps testing old and new
   versions of GCC, Clang, MSVC, and other compilers on Linux, macOS, and Windows.
 - **Keep the quality assurance up.** Every change keeps the test coverage at 100%, passes the static and dynamic
@@ -37,7 +37,65 @@ work items are tracked in the [GitHub milestones](https://github.com/nlohmann/js
 
 ## Version 4.0
 
-There is no decision yet on whether or when a version 4.0 with breaking changes will be released. Proposals that need
-a major version, for instance stricter type conversions, are collected in issue
-[#3453](https://github.com/nlohmann/json/issues/3453). Until then, such changes are only added as opt-in behavior
-behind feature macros.
+There is no release date for version 4.0 yet. Proposals that need a major version, for instance stricter type
+conversions, are collected in issue [#3453](https://github.com/nlohmann/json/issues/3453).
+
+!!! note "Not final"
+
+    The plan for version 4.0 described below is not final and may still change: macros may be added to or removed from
+    the list, and planned defaults may be revised. Any such change will be documented on this page.
+
+### Trying out 4.0 today
+
+Version 4.0 will not be developed on a separate branch. Instead, every breaking change is first added to a 3.x release
+behind a macro whose default keeps the 3.x behavior. Version 4.0 then switches the defaults and removes the macros.
+Version 4.0 is therefore the sum of these macros: you can try it on the 3.x release train today by defining each macro
+to its 4.0 value and fixing what no longer compiles or behaves differently. Once your code works with all of them, it
+is ready for version 4.0.
+
+The following macros guard changes that are planned to become the default in version 4.0:
+
+| Macro                                                                                                            | 3.x default | 4.0 behavior                                                                                                                  | CMake option                                                                                                       | Added  |
+|------------------------------------------------------------------------------------------------------------------|-------------|-------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|--------|
+| [`JSON_USE_IMPLICIT_CONVERSIONS`](../api/macros/json_use_implicit_conversions.md)                                | `1`         | `0`: no implicit conversions from `basic_json` to other types; use [`get`](../api/basic_json/get.md) instead                  | [`JSON_ImplicitConversions`](../integration/cmake.md#json_implicitconversions)                                     | 3.9.0  |
+| [`JSON_USE_GLOBAL_UDLS`](../api/macros/json_use_global_udls.md)                                                  | `1`         | `0`: the string literals `_json` and `_json_pointer` are only available in namespace `nlohmann::literals`                    | [`JSON_GlobalUDLs`](../integration/cmake.md#json_globaludls)                                                       | 3.11.0 |
+| [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md)      | `0`         | removed: the deprecated legacy comparison of discarded values can no longer be enabled                                        | [`JSON_LegacyDiscardedValueComparison`](../integration/cmake.md#json_legacydiscardedvaluecomparison)               | 3.11.0 |
+| [`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md)                              | `0`         | `1`: single-element brace initialization such as `#!cpp json j{obj};` copies the element instead of creating an array         | –                                                                                                                  | 3.13.0 |
+| [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)                                  | `0`         | `1`: reading from a stream does not consume the character after a number                                                      | –                                                                                                                  | 3.13.0 |
+| [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)                                          | `0`         | `1`: a NUL byte in the input is a parse error instead of the end of input                                                     | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling)                                         | 3.13.0 |
+
+For example, the following makes a 3.x release behave like version 4.0 with respect to these changes:
+
+```cpp
+#define JSON_USE_IMPLICIT_CONVERSIONS 0
+#define JSON_USE_GLOBAL_UDLS 0
+#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#define JSON_BRACE_INIT_COPY_SEMANTICS 1
+#define JSON_PRECISE_STREAM_POSITION 1
+#define JSON_STRICT_NUL_HANDLING 1
+#include <nlohmann/json.hpp>
+```
+
+The macros must be defined before the library header is included; setting them once in the build system is the easiest
+way to achieve this.
+
+### Removal of deprecated functions
+
+Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your
+code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to
+replace each of them.
+
+| Deprecated                                                                                                                                                                                                                                         | Since  | Migration                                                                        |
+|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------|
+| `#!cpp operator<<(basic_json&, std::istream&)`                                                                                                                                                                                                     | 3.0.0  | [Parsing](../integration/migration_guide.md#parsing)                             |
+| `#!cpp operator>>(const basic_json&, std::ostream&)`                                                                                                                                                                                               | 3.0.0  | [Miscellaneous functions](../integration/migration_guide.md#miscellaneous-functions) |
+| `iterator_wrapper`                                                                                                                                                                                                                                 | 3.1.0  | [Miscellaneous functions](../integration/migration_guide.md#miscellaneous-functions) |
+| [`parse`](../api/basic_json/parse.md), [`accept`](../api/basic_json/accept.md), and [`sax_parse`](../api/basic_json/sax_parse.md) with an initializer list `{ptr, len}` or `{first, last}`                                                         | 3.8.0  | [Parsing](../integration/migration_guide.md#parsing)                             |
+| [`from_bson`](../api/basic_json/from_bson.md), [`from_cbor`](../api/basic_json/from_cbor.md), [`from_msgpack`](../api/basic_json/from_msgpack.md), and [`from_ubjson`](../api/basic_json/from_ubjson.md) with `(ptr, len)` or an initializer list | 3.8.0  | [Parsing](../integration/migration_guide.md#parsing)                             |
+| [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md)                                                                                                                                                                      | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
+| [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer                                                           | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
+| Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md)                                                              | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
+
+The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above.
+
+New breaking changes will follow the same path: they are added to these tables when they land in a 3.x release.

docs/mkdocs/docs/integration/migration_guide.md

@@ -1,10 +1,13 @@
 # Migration Guide
 
 This page collects some guidelines on how to future-proof your code for future versions of this library.
+The [roadmap](../community/roadmap.md#version-40) lists what will change in version 4.0, including the macros that let
+you try its behavior with a 3.x release; this page describes how to adjust your code.
 
 ## Replace deprecated functions
 
-The following functions have been deprecated and will be removed in the next major version (i.e., 4.0.0). All
+The following functions have been deprecated and will be removed in the next major version (i.e., 4.0.0), see the
+[roadmap](../community/roadmap.md#removal-of-deprecated-functions) for an overview. All
 deprecations are annotated with
 [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which
 function to use instead.
@@ -34,8 +37,9 @@ function to use instead.
   [`accept`](../api/basic_json/accept.md), [`sax_parse`](../api/basic_json/sax_parse.md),
   [`from_cbor`](../api/basic_json/from_cbor.md), [`from_msgpack`](../api/basic_json/from_msgpack.md),
   [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md) via initializer
-  lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
-  `from_cbor({ptr, len})`.
+  lists is deprecated since 3.8.0. The same holds for passing a pointer and a length as two arguments to the `from_*`
+  functions. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
+  `from_cbor({ptr, len})` or `from_cbor(ptr, len)`.
 
     === "Deprecated"
   

include/nlohmann/detail/conversions/from_json.hpp

@@ -353,7 +353,7 @@ template < typename BasicJsonType, typename T, std::size_t... Idx >
 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
                      identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
 {
-    return { { j.at(Idx).template get<T>()... } };
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
 }
 
 template < typename BasicJsonType, typename T, std::size_t N >
@@ -502,7 +502,7 @@ using tuple_type = std::tuple < decltype(from_json_tuple_get_impl(std::declval<B
 template<std::size_t PTagValue, typename... Args, typename BasicJsonType, std::size_t... Idx>
 tuple_type<PTagValue, BasicJsonType, Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
 {
-    return tuple_type<PTagValue, BasicJsonType, Args...>(from_json_tuple_get_impl(j.at(Idx), detail::identity_tag<Args> {}, detail::priority_tag<PTagValue> {})...);
+    return tuple_type<PTagValue, BasicJsonType, Args...>(from_json_tuple_get_impl(std::forward<BasicJsonType>(j).at(Idx), detail::identity_tag<Args> {}, detail::priority_tag<PTagValue> {})...);
 }
 
 template<std::size_t PTagValue, typename BasicJsonType>
@@ -514,8 +514,8 @@ std::tuple<> from_json_tuple_impl_base(BasicJsonType& /*unused*/, index_sequence
 template < typename BasicJsonType, class A1, class A2 >
 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
 {
-    return {j.at(0).template get<A1>(),
-            j.at(1).template get<A2>()};
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
 }
 
 template<typename BasicJsonType, typename A1, typename A2>

include/nlohmann/detail/input/input_adapters.hpp

@@ -763,7 +763,6 @@ struct container_input_adapter_factory< ContainerType,
 
            static adapter_type create(ContainerType&& container)
 {
-    // NOLINTNEXTLINE(bugprone-use-after-move,hicpp-invalid-access-moved) forwarded twice on purpose, so begin() and end() see the same value category and yield matching iterator types
     return input_adapter(begin(std::forward<ContainerType>(container)), end(std::forward<ContainerType>(container)));
 }
        };

include/nlohmann/detail/string_concat.hpp

@@ -39,6 +39,7 @@ inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
 template<typename... Args>
 inline std::size_t concat_length(const char* cstr, const Args& ... rest)
 {
+    // cppcheck-suppress ignoredReturnValue
     return ::strlen(cstr) + concat_length(rest...);
 }
 

include/nlohmann/ordered_map.hpp

@@ -70,41 +70,14 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
         return *this;
     }
 
-private:
-    /// @brief find the entry for @a key, for either constness of @a self
-    /// @note the single place that performs the linear key search
-    template<typename Self, typename KeyType>
-    static auto find_impl(Self& self, KeyType&& key) -> decltype(self.begin())
-    {
-        for (auto it = self.begin(); it != self.end(); ++it)
-        {
-            if (self.m_compare(it->first, key))
-            {
-                return it;
-            }
-        }
-        return self.end();
-    }
-
-    /// @brief remove the entry @a it points to, preserving order
-    /// @note keys are not movable, so the tail is destroyed and re-constructed in place
-    void erase_at(iterator it)
-    {
-        for (auto next = it; ++next != this->end(); ++it)
-        {
-            it->~value_type(); // Destroy but keep allocation
-            new (&*it) value_type{std::move(*next)};
-        }
-        Container::pop_back();
-    }
-
-public:
     std::pair<iterator, bool> emplace(const key_type& key, T&& t)
     {
-        const auto it = find_impl(*this, key);
-        if (it != this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            return {it, false};
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
         }
         Container::emplace_back(key, std::forward<T>(t));
         return {std::prev(this->end()), true};
@@ -114,10 +87,12 @@ public:
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     std::pair<iterator, bool> emplace(KeyType && key, T && t)
     {
-        const auto it = find_impl(*this, key);
-        if (it != this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            return {it, false};
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
         }
         Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
         return {std::prev(this->end()), true};
@@ -149,55 +124,75 @@ public:
 
     T& at(const key_type& key)
     {
-        const auto it = find_impl(*this, key);
-        if (it == this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            JSON_THROW(std::out_of_range("key not found"));
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
         }
-        return it->second;
+
+        JSON_THROW(std::out_of_range("key not found"));
     }
 
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        const auto it = find_impl(*this, key);
-        if (it == this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            JSON_THROW(std::out_of_range("key not found"));
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
         }
-        return it->second;
+
+        JSON_THROW(std::out_of_range("key not found"));
     }
 
     const T& at(const key_type& key) const
     {
-        const auto it = find_impl(*this, key);
-        if (it == this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            JSON_THROW(std::out_of_range("key not found"));
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
         }
-        return it->second;
+
+        JSON_THROW(std::out_of_range("key not found"));
     }
 
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        const auto it = find_impl(*this, key);
-        if (it == this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            JSON_THROW(std::out_of_range("key not found"));
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
         }
-        return it->second;
+
+        JSON_THROW(std::out_of_range("key not found"));
     }
 
     size_type erase(const key_type& key)
     {
-        const auto it = find_impl(*this, key);
-        if (it != this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            erase_at(it);
-            return 1;
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
         }
         return 0;
     }
@@ -206,11 +201,19 @@ public:
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        const auto it = find_impl(*this, key);
-        if (it != this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            erase_at(it);
-            return 1;
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
         }
         return 0;
     }
@@ -275,38 +278,80 @@ public:
 
     size_type count(const key_type& key) const
     {
-        return find_impl(*this, key) != this->end() ? 1 : 0;
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
     }
 
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        return find_impl(*this, key) != this->end() ? 1 : 0;
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
     }
 
     iterator find(const key_type& key)
     {
-        return find_impl(*this, key);
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
     }
 
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        return find_impl(*this, key);
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
     }
 
     const_iterator find(const key_type& key) const
     {
-        return find_impl(*this, key);
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
     }
 
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
     const_iterator find(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
     {
-        return find_impl(*this, key);
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
     }
 
     std::pair<iterator, bool> insert( value_type&& value )
@@ -316,10 +361,12 @@ public:
 
     std::pair<iterator, bool> insert( const value_type& value )
     {
-        const auto it = find_impl(*this, value.first);
-        if (it != this->end())
+        for (auto it = this->begin(); it != this->end(); ++it)
         {
-            return {it, false};
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
         }
         Container::push_back(value);
         return {--this->end(), true};

tests/src/unit-class_parser.cpp

@@ -2525,10 +2525,12 @@ TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
 
         SECTION("move constructor resets the moved-from value to npos")
         {
-            // basic_json(basic_json&&) (json.hpp, around line 1944) copies
+            // basic_json(basic_json&&) (json.hpp, around line 1265) copies
             // other's start_position/end_position into *this and then resets
-            // other's to npos. Only the top-level moved-from value is
-            // affected; its (moved-away) children are gone along with it.
+            // other's to npos (see the cppcheck-suppress[accessForwarded]
+            // annotation there, which flags this reset as worth a second
+            // look). Only the top-level moved-from value is affected; its
+            // (moved-away) children are gone along with it.
             const std::string s = R"({"a":1,"b":[1,2,3]})";
             json a = json::parse(s);
             const auto a_start = a.start_pos();

tests/src/unit-modifiers.cpp

@@ -618,49 +618,6 @@ TEST_CASE("modifiers")
             }
         }
 
-        SECTION("rvalue at position moves rather than copies")
-        {
-            // regression test: insert(pos, basic_json&&) used to forward to
-            // insert(pos, const basic_json&) because the named rvalue
-            // reference parameter is itself an lvalue, so it always
-            // deep-copied its argument instead of moving it
-            json j_big = std::string(1000, 'x');
-            const auto* const original_buffer = j_big.get_ref<const std::string&>().data();
-
-            auto it = j_array.insert(j_array.begin(), std::move(j_big));
-            CHECK(j_array.size() == 5);
-            CHECK(*it == json(std::string(1000, 'x')));
-            CHECK((*it).get_ref<const std::string&>().data() == original_buffer);
-
-            // the moved-from value is null, the same as after push_back(&&)
-            CHECK(j_big.is_null()); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
-        }
-
-        SECTION("self-aliasing insertion")
-        {
-            SECTION("without reallocation")
-            {
-                json j_self = {1, 2, 3, 4};
-                j_self.get_ref<json::array_t&>().reserve(j_self.size() + 1);
-
-                auto it = j_self.insert(j_self.begin(), std::move(j_self[1]));
-                CHECK(j_self.size() == 5);
-                CHECK(*it == json(2));
-                CHECK(j_self == json({2, 1, nullptr, 3, 4}));
-            }
-
-            SECTION("with reallocation")
-            {
-                json j_self = {1, 2, 3, 4};
-                j_self.get_ref<json::array_t&>().shrink_to_fit();
-
-                auto it = j_self.insert(j_self.begin(), std::move(j_self[1]));
-                CHECK(j_self.size() == 5);
-                CHECK(*it == json(2));
-                CHECK(j_self == json({2, 1, nullptr, 3, 4}));
-            }
-        }
-
         SECTION("copies at position")
         {
             SECTION("insert before begin()")