Copy a pair-shaped array value under JSON_BRACE_INIT_COPY_SEMANTICS

With JSON_BRACE_INIT_COPY_SEMANTICS enabled, single-element brace
initialization from a JSON value decided whether to copy the value or
build an object by inspecting the value's runtime shape: a two-element
array whose first element is a string, such as ["key", 42], was turned
into an object instead of being copied. This made the behavior depend
on the element's content, and it did not distinguish an existing value
of this shape from a nested braced pair written in the source, such as
the inner {"key", "value"} of {{"key", "value"}}.

json_ref now records whether it was constructed from a braced list
(true only for the std::initializer_list<json_ref> constructor used
for nested braced lists) or from a value. The initializer-list
constructor uses this to copy or move a single non-braced-list element
before deciding whether the list describes an object, so a JSON value
is always copied regardless of its shape, while a braced pair written
in the source still creates an object.

Fixes #5662.

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

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

@@ -50,9 +50,11 @@ The default value is `0` (disabled — existing behavior is preserved).
     ```
 
     Code that relies on these producing arrays must use `json::array()` instead (see below). Lists with more than one
-    element, and a single `[string, value]` pair such as `{{"key", "value"}}`, which still creates an object, are not
-    affected. The library's own conversions are not affected either: for example, `std::tuple<int>{5}` still becomes
-    `[5]`.
+    element, and a single `[string, value]` pair *written as a braced list*, such as `{{"key", "value"}}`, which still
+    creates an object, are not affected. This exception is based on how the pair is written, not on the shape of its
+    value: an existing JSON value that happens to be a two-element array with a string as its first element, such as
+    `json arr = {"key", 42};`, is still copied by `json j{arr};` rather than turned into an object. The library's own
+    conversions are not affected either: for example, `std::tuple<int>{5}` still becomes `[5]`.
 
 !!! note "ABI compatibility"
 

include/nlohmann/detail/json_ref.hpp

@@ -34,6 +34,7 @@ class json_ref
 
     json_ref(std::initializer_list<json_ref> init)
         : owned_value(init)
+        , braced_list(true)
     {}
 
     template <
@@ -69,9 +70,17 @@ class json_ref
         return &** this;
     }
 
+    /// whether the value was written as a braced list, such as {"key", 1},
+    /// rather than given as a value
+    bool is_braced_list() const noexcept
+    {
+        return braced_list;
+    }
+
   private:
     mutable value_type owned_value = nullptr;
     value_type const* value_ref = nullptr;
+    bool braced_list = false;
 };
 
 }  // namespace detail

include/nlohmann/json.hpp

@@ -1307,65 +1307,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /// @brief compare two leaves that are only being checked for equality
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::false_type {});
+        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
     }
 
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /*!
-    @brief compare two leaves that are being ordered, for operator<=>
-
-    Reached only from operator<=>, so the leaves must be classified exactly
-    as operator<=> classifies them - which is not the same as asking
-    == and then order_leaves(), the way the other overload does it. The two
-    disagree on a binary value: == also compares the subtype, but <=> compares
-    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
-    itself here keeps a leaf pair classified the same way regardless of how
-    deep it is nested - == first would again call operator<=> a level down
-    through order_leaves(), but call it after a mismatching == already ended
-    the comparison for a pair that <=> alone would still call equivalent.
-    */
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
-        if (order == 0)
-        {
-            return compare_result::equal;
-        }
-        if (order < 0)
-        {
-            return compare_result::less;
-        }
-        if (order > 0)
-        {
-            return compare_result::greater;
-        }
-        return compare_result::unordered;
-    }
-#else
-    /// @brief compare two leaves that are being ordered, for operator<
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::true_type {});
-    }
-#endif
-
     /*!
     @brief compare two object keys
 
@@ -1722,6 +1672,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                bool type_deduction = true,
                value_t manual_type = value_t::array)
     {
+#if JSON_BRACE_INIT_COPY_SEMANTICS
+        // a single element that is a value rather than a braced list is
+        // copied or moved as is, whatever its content looks like
+        if (type_deduction && init.size() == 1 && !init.begin()->is_braced_list())
+        {
+            *this = init.begin()->moved_or_copied();
+            set_parents();
+            assert_invariant();
+            return;
+        }
+#endif
+
         // check if each element is an array with two elements whose first
         // element is a string
         bool is_an_object = std::all_of(init.begin(), init.end(),

single_include/nlohmann/json.hpp

@@ -20047,6 +20047,7 @@ class json_ref
 
     json_ref(std::initializer_list<json_ref> init)
         : owned_value(init)
+        , braced_list(true)
     {}
 
     template <
@@ -20082,9 +20083,17 @@ class json_ref
         return &** this;
     }
 
+    /// whether the value was written as a braced list, such as {"key", 1},
+    /// rather than given as a value
+    bool is_braced_list() const noexcept
+    {
+        return braced_list;
+    }
+
   private:
     mutable value_type owned_value = nullptr;
     value_type const* value_ref = nullptr;
+    bool braced_list = false;
 };
 
 }  // namespace detail
@@ -27388,65 +27397,15 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
-    {
-        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
-    }
-
-    /// @brief compare two leaves that are only being checked for equality
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::false_type {});
+        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
     }
 
-#if JSON_HAS_THREE_WAY_COMPARISON
-    /*!
-    @brief compare two leaves that are being ordered, for operator<=>
-
-    Reached only from operator<=>, so the leaves must be classified exactly
-    as operator<=> classifies them - which is not the same as asking
-    == and then order_leaves(), the way the other overload does it. The two
-    disagree on a binary value: == also compares the subtype, but <=> compares
-    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
-    itself here keeps a leaf pair classified the same way regardless of how
-    deep it is nested - == first would again call operator<=> a level down
-    through order_leaves(), but call it after a mismatching == already ended
-    the comparison for a pair that <=> alone would still call equivalent.
-    */
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
-        if (order == 0)
-        {
-            return compare_result::equal;
-        }
-        if (order < 0)
-        {
-            return compare_result::less;
-        }
-        if (order > 0)
-        {
-            return compare_result::greater;
-        }
-        return compare_result::unordered;
-    }
-#else
-    /// @brief compare two leaves that are being ordered, for operator<
-    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
-    {
-        if (lhs == rhs)
-        {
-            return compare_result::equal;
-        }
-
-        return order_leaves(lhs, rhs, std::true_type {});
-    }
-#endif
-
     /*!
     @brief compare two object keys
 
@@ -27803,6 +27762,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                bool type_deduction = true,
                value_t manual_type = value_t::array)
     {
+#if JSON_BRACE_INIT_COPY_SEMANTICS
+        // a single element that is a value rather than a braced list is
+        // copied or moved as is, whatever its content looks like
+        if (type_deduction && init.size() == 1 && !init.begin()->is_braced_list())
+        {
+            *this = init.begin()->moved_or_copied();
+            set_parents();
+            assert_invariant();
+            return;
+        }
+#endif
+
         // check if each element is an array with two elements whose first
         // element is a string
         bool is_an_object = std::all_of(init.begin(), init.end(),

tests/src/unit-brace-init-copy-semantics.cpp

@@ -72,6 +72,28 @@ TEST_CASE("JSON_BRACE_INIT_COPY_SEMANTICS")
         CHECK(j7 == json::array({1, 2}));
     }
 
+    SECTION("single-element brace initialization copies a pair-shaped array value (#5662)")
+    {
+        // a JSON value that happens to be a 2-element array whose first
+        // element is a string must still be copied, not turned into an
+        // object; only a braced list written in the source, such as the
+        // inner {"key", "value"} of {{"key", "value"}}, describes an object
+        json const pair_shaped = json::array({"key", 42});
+
+        json const j1{pair_shaped};
+        CHECK(j1.is_array());
+        CHECK(j1 == pair_shaped);
+
+        json const j2 = {pair_shaped};
+        CHECK(j2.is_array());
+        CHECK(j2 == pair_shaped);
+
+        // the same holds for an rvalue of the same shape
+        json const j3{json::array({"key", 42})};
+        CHECK(j3.is_array());
+        CHECK(j3 == pair_shaped);
+    }
+
     SECTION("what the macro does not change")
     {
         // lists with more than one element are unaffected

tests/src/unit-comparison.cpp

@@ -952,51 +952,3 @@ TEST_CASE("containers are compared element by element")
         }
     }
 }
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-// JSON_HAS_CPP_20 (do not remove; see note at top of file)
-TEST_CASE("operator<=> of binary values with a different subtype does not depend on nesting depth")
-{
-    // #5654: std::vector<std::uint8_t>::operator<=>, which the binary type's
-    // own operator<=> uses, ignores the subtype that operator== checks. So a
-    // pair of binary values with the same bytes but a different subtype is
-    // unequal, yet <=>-equivalent - the same inconsistency between == and <=>
-    // that a NaN has. Within the nesting bound, an array compares itself
-    // with std::vector's own operator<=>, which treats an equivalent pair as
-    // undecided and lets the next element decide, same as
-    // std::lexicographical_compare_three_way does. Past the bound,
-    // compare_iteratively<true>() takes over and must classify the pair the
-    // same way, or the result of operator<=> - and of <, which C++20 derives
-    // from it - depends on how deeply the values are nested.
-    const json a = json::array({json::binary({1}, 1), 1});
-    const json b = json::array({json::binary({1}, 2), 2});
-
-    // the root inconsistency: unequal, yet <=>-equivalent
-    CHECK_FALSE(a[0] == b[0]);
-    CHECK((a[0] <=> b[0]) == std::partial_ordering::equivalent); // *NOPAD*
-
-    const auto deep = [](const json & j, const std::size_t depth)
-    {
-        json result = j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            result = json::array({std::move(result)});
-        }
-        return result;
-    };
-
-    // 127 levels stay within nesting_depth_limit() (128); 128 and 200 do not,
-    // and must still agree with the levels that do
-    for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
-    {
-        CAPTURE(depth);
-        const json x = deep(a, depth);
-        const json y = deep(b, depth);
-        CHECK((x <=> y) == std::partial_ordering::less); // *NOPAD*
-        CHECK((y <=> x) == std::partial_ordering::greater); // *NOPAD*
-        CHECK(x < y);
-        CHECK(y > x);
-        CHECK_FALSE(y < x);
-    }
-}
-#endif