Merge branch 'develop' into claude/noexception-value-json-pointer-5672

Conflicts:
- tests/src/unit-disabled_exceptions.cpp: kept both new sections (#5672 value(json_pointer) test and develop's ordered_json growth test)

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

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

@@ -272,15 +272,6 @@ basic_json(basic_json&& other) noexcept;
         When used without parentheses around an empty initializer list, `basic_json()` is called instead of this
         function, yielding the JSON `#!json null` value.
 
-- Overload 4:
-
-    !!! info "Implicit conversion"
-
-        The conversion is implicit unless [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md)
-        is defined to `0` and `BasicJsonType::string_t` differs from `string_t`. In that case, the constructor is
-        `explicit`, so a JSON value with a different string type is no longer silently converted, for example when it is
-        passed to a function taking `#!cpp const json&`. Write `#!cpp json(other)` or `#!cpp other.get<json>()` instead.
-
 - Overload 7:
 
     !!! info "Preconditions"
@@ -429,8 +420,7 @@ basic_json(basic_json&& other) noexcept;
 1. Since version 1.0.0.
 2. Since version 1.0.0.
 3. Since version 2.1.0.
-4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
-   version 3.13.0.
+4. Since version 3.2.0.
 5. Since version 1.0.0.
 6. Since version 1.0.0.
 7. Since version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range

docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md

@@ -5,9 +5,7 @@
 ```
 
 When defined to `0`, implicit conversions are switched off. By default, implicit conversions are switched on. The
-value directly affects [`operator ValueType`](../basic_json/operator_ValueType.md) and the
-[converting constructor](../basic_json/basic_json.md) from a `basic_json` specialization with a different string
-type (overload 4).
+value directly affects [`operator ValueType`](../basic_json/operator_ValueType.md).
 
 ## Default definition
 
@@ -59,25 +57,6 @@ By default, implicit conversions are enabled.
     auto s = j.get<std::string>();
     ```
 
-??? example "Conversion between `basic_json` specializations"
-
-    A `basic_json` specialization with a different string type is also no longer converted implicitly when
-    `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`:
-
-    ```cpp
-    using wjson = nlohmann::basic_json<std::map, std::vector, std::wstring>;
-
-    void load(const nlohmann::json& j);
-
-    wjson wj = /* ... */;
-    load(wj);                            // error: no implicit conversion
-    load(nlohmann::json(wj));            // OK: explicit conversion
-    load(wj.get<nlohmann::json>());      // OK: explicit conversion
-    ```
-
-    Specializations that share the same string type, such as `json` and `ordered_json`, remain implicitly
-    convertible.
-
 ## See also
 
 - [**operator ValueType**](../basic_json/operator_ValueType.md) - get a value (implicit)
@@ -87,4 +66,3 @@ By default, implicit conversions are enabled.
 ## Version history
 
 - Added in version 3.9.0.
-- Also affects the conversion between `basic_json` specializations with different string types since version 3.13.0.

include/nlohmann/detail/conversions/to_json.hpp

@@ -291,9 +291,7 @@ void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(std::is_not
 {
     if (opt.has_value())
     {
-        // explicit construction, as the conversion from a basic_json with a different
-        // string type is explicit if JSON_USE_IMPLICIT_CONVERSIONS is 0 (#2649)
-        j = BasicJsonType(*opt);
+        j = *opt;
     }
     else
     {

include/nlohmann/detail/json_pointer.hpp

@@ -679,19 +679,29 @@ class json_pointer
                         return nullptr;
                     }
 
-                    // may throw parse_error.106/109 for a malformed index; an
-                    // index that is syntactically valid but cannot be
-                    // represented (out_of_range.404/410) is treated like an
-                    // out-of-range index below
-                    typename BasicJsonType::size_type idx{};
-                    JSON_TRY
+                    // tokens that array_index() rejects with parse_error.106/109
+                    // are passed on to it; all other tokens that it would reject
+                    // with out_of_range.404/410 are detected here, so that this
+                    // also works without exceptions
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 && !(reference_token[0] >= '1' && reference_token[0] <= '9')))
                     {
-                        idx = array_index<BasicJsonType>(reference_token);
+                        static_cast<void>(array_index<BasicJsonType>(reference_token)); // throws parse_error.106/109
                     }
-                    JSON_INTERNAL_CATCH (detail::out_of_range&)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.empty() || !std::all_of(reference_token.begin(), reference_token.end(), [](const char c)
+                {
+                    return c >= '0' && c <= '9';
+                })))
                     {
                         return nullptr;
                     }
+                    errno = 0; // strtoull() does not reset errno on success
+                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
+                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &p_end, 10); // NOLINT(runtime/int)
+                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
+                    {
+                        return nullptr;
+                    }
+                    const auto idx = static_cast<typename BasicJsonType::size_type>(magnitude);
 
                     if (JSON_HEDLEY_UNLIKELY(idx >= ptr->m_data.m_value.array->size()))
                     {

include/nlohmann/json.hpp

@@ -1606,42 +1606,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-  private:
-    /// whether a basic_json specialization can be converted implicitly into this one;
-    /// with JSON_USE_IMPLICIT_CONVERSIONS set to 0, this is only the case if both share
-    /// the same string type (see https://github.com/nlohmann/json/issues/2649)
-    template<typename BasicJsonType>
-    using is_implicitly_convertible_basic_json = std::integral_constant < bool,
-          (JSON_USE_IMPLICIT_CONVERSIONS != 0)
-          || std::is_same<typename BasicJsonType::string_t, string_t>::value >;
-
-    /// tag to select the constructor that performs the conversion from another basic_json specialization
-    struct convert_basic_json_tag {};
-
-  public:
     /// @brief create a JSON value from an existing one
     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
     template < typename BasicJsonType,
                detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
-                   && is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
     basic_json(const BasicJsonType& val)
-        : basic_json(val, convert_basic_json_tag{})
-    {}
-
-    /// @brief create a JSON value from an existing one
-    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-    template < typename BasicJsonType,
-               detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
-                   && !is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
-    explicit basic_json(const BasicJsonType& val)
-        : basic_json(val, convert_basic_json_tag{})
-    {}
-
-  private:
-    template<typename BasicJsonType>
-    basic_json(const BasicJsonType& val, convert_basic_json_tag /*unused*/)
 #if JSON_DIAGNOSTIC_POSITIONS
         : start_position(val.start_pos()),
           end_position(val.end_pos())
@@ -1697,7 +1667,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-  public:
     /// @brief create a container (array or object) from an initializer list
     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
     basic_json(initializer_list_t init,
@@ -2464,7 +2433,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    int > = 0 >
     BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
     {
-        return BasicJsonType(*this);
+        return *this;
     }
 
     /*!
@@ -2603,7 +2572,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                  int> = 0>
     ValueType & get_to(ValueType& v) const
     {
-        v = ValueType(*this);
+        v = *this;
         return v;
     }
 

single_include/nlohmann/json.hpp

@@ -6822,9 +6822,7 @@ void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(std::is_not
 {
     if (opt.has_value())
     {
-        // explicit construction, as the conversion from a basic_json with a different
-        // string type is explicit if JSON_USE_IMPLICIT_CONVERSIONS is 0 (#2649)
-        j = BasicJsonType(*opt);
+        j = *opt;
     }
     else
     {
@@ -20293,19 +20291,29 @@ class json_pointer
                         return nullptr;
                     }
 
-                    // may throw parse_error.106/109 for a malformed index; an
-                    // index that is syntactically valid but cannot be
-                    // represented (out_of_range.404/410) is treated like an
-                    // out-of-range index below
-                    typename BasicJsonType::size_type idx{};
-                    JSON_TRY
+                    // tokens that array_index() rejects with parse_error.106/109
+                    // are passed on to it; all other tokens that it would reject
+                    // with out_of_range.404/410 are detected here, so that this
+                    // also works without exceptions
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 && !(reference_token[0] >= '1' && reference_token[0] <= '9')))
                     {
-                        idx = array_index<BasicJsonType>(reference_token);
+                        static_cast<void>(array_index<BasicJsonType>(reference_token)); // throws parse_error.106/109
                     }
-                    JSON_INTERNAL_CATCH (detail::out_of_range&)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.empty() || !std::all_of(reference_token.begin(), reference_token.end(), [](const char c)
+                {
+                    return c >= '0' && c <= '9';
+                })))
                     {
                         return nullptr;
                     }
+                    errno = 0; // strtoull() does not reset errno on success
+                    char* p_end = nullptr; // NOLINT(misc-const-correctness)
+                    const unsigned long long magnitude = std::strtoull(reference_token.data(), &p_end, 10); // NOLINT(runtime/int)
+                    if (JSON_HEDLEY_UNLIKELY(errno == ERANGE || magnitude >= static_cast<unsigned long long>((std::numeric_limits<typename BasicJsonType::size_type>::max)()))) // NOLINT(runtime/int)
+                    {
+                        return nullptr;
+                    }
+                    const auto idx = static_cast<typename BasicJsonType::size_type>(magnitude);
 
                     if (JSON_HEDLEY_UNLIKELY(idx >= ptr->m_data.m_value.array->size()))
                     {
@@ -28535,42 +28543,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-  private:
-    /// whether a basic_json specialization can be converted implicitly into this one;
-    /// with JSON_USE_IMPLICIT_CONVERSIONS set to 0, this is only the case if both share
-    /// the same string type (see https://github.com/nlohmann/json/issues/2649)
-    template<typename BasicJsonType>
-    using is_implicitly_convertible_basic_json = std::integral_constant < bool,
-        (JSON_USE_IMPLICIT_CONVERSIONS != 0)
-        || std::is_same<typename BasicJsonType::string_t, string_t>::value >;
-
-    /// tag to select the constructor that performs the conversion from another basic_json specialization
-    struct convert_basic_json_tag {};
-
-  public:
     /// @brief create a JSON value from an existing one
     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
     template < typename BasicJsonType,
                detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
-                   && is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
     basic_json(const BasicJsonType& val)
-        : basic_json(val, convert_basic_json_tag{})
-    {}
-
-    /// @brief create a JSON value from an existing one
-    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-    template < typename BasicJsonType,
-               detail::enable_if_t <
-                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
-                   && !is_implicitly_convertible_basic_json<BasicJsonType>::value, int > = 0 >
-    explicit basic_json(const BasicJsonType& val)
-        : basic_json(val, convert_basic_json_tag{})
-    {}
-
-  private:
-    template<typename BasicJsonType>
-    basic_json(const BasicJsonType& val, convert_basic_json_tag /*unused*/)
 #if JSON_DIAGNOSTIC_POSITIONS
         : start_position(val.start_pos()),
           end_position(val.end_pos())
@@ -28626,7 +28604,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         assert_invariant();
     }
 
-  public:
     /// @brief create a container (array or object) from an initializer list
     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
     basic_json(initializer_list_t init,
@@ -29393,7 +29370,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                    int > = 0 >
     BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
     {
-        return BasicJsonType(*this);
+        return *this;
     }
 
     /*!
@@ -29532,7 +29509,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                  int> = 0>
     ValueType & get_to(ValueType& v) const
     {
-        v = ValueType(*this);
+        v = *this;
         return v;
     }
 

tests/src/unit-alt-string.cpp

@@ -13,7 +13,6 @@
 
 #include <cstdint>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -420,41 +419,6 @@ TEST_CASE("alternative string type")
         CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
     }
 
-    SECTION("conversion between basic_json specializations (#2649)")
-    {
-        // explicit conversions are always possible
-        CHECK(std::is_constructible<nlohmann::json, alt_json>::value);
-        CHECK(std::is_constructible<alt_json, nlohmann::json>::value);
-        CHECK(std::is_constructible<nlohmann::json, nlohmann::ordered_json>::value);
-        CHECK(std::is_constructible<nlohmann::ordered_json, nlohmann::json>::value);
-
-        // specializations with the same string type are implicitly convertible
-        CHECK(std::is_convertible<nlohmann::ordered_json, nlohmann::json>::value);
-        CHECK(std::is_convertible<nlohmann::json, nlohmann::ordered_json>::value);
-
-        // specializations with different string types are only implicitly convertible
-        // if implicit conversions are enabled
-#if JSON_USE_IMPLICIT_CONVERSIONS
-        CHECK(std::is_convertible<alt_json, nlohmann::json>::value);
-        CHECK(std::is_convertible<nlohmann::json, alt_json>::value);
-#else
-        CHECK_FALSE(std::is_convertible<alt_json, nlohmann::json>::value);
-        CHECK_FALSE(std::is_convertible<nlohmann::json, alt_json>::value);
-#endif
-
-        // get<BasicJsonType>() works in either case
-        const nlohmann::json j = {{"foo", 1}, {"bar", true}};
-        CHECK(j.get<nlohmann::ordered_json>() == nlohmann::ordered_json(j));
-        // (only a number is converted here, as objects and strings are affected by #3425)
-        CHECK(nlohmann::json(42).get<alt_json>() == 42);
-        CHECK(alt_json(nlohmann::json(42)) == 42);
-
-        // get_to() also works in either case
-        alt_json a;
-        nlohmann::json(42).get_to(a);
-        CHECK(a == 42);
-    }
-
     SECTION("strict enum")
     {
         // regression test for #5667: NLOHMANN_JSON_SERIALIZE_ENUM_STRICT's from_json

tests/src/unit-disabled_exceptions.cpp

@@ -47,6 +47,21 @@ TEST_CASE("Tests with disabled exceptions")
         delete sax_no_exception::error_string; // NOLINT(cppcoreguidelines-owning-memory)
     }
 
+    SECTION("issue #5672 - value(json_pointer, default) must not abort for array tokens that are not a valid index")
+    {
+        const json j = {1, 2, 3};
+
+        // a syntactically valid index that is out of range for this array
+        CHECK(j.value("/7"_json_pointer, 42) == 42);
+        // a reference token that is not a number at all
+        CHECK(j.value("/1a"_json_pointer, 42) == 42);
+        // the empty reference token (JSON pointer "/")
+        CHECK(j.value("/"_json_pointer, 42) == 42);
+        // an index whose magnitude does not fit into size_type
+        CHECK(j.value("/99999999999999999999999"_json_pointer, 42) == 42);
+        CHECK(j.value("/18446744073709551615"_json_pointer, 42) == 42);
+    }
+
     SECTION("growing an ordered_json object")
     {
         auto j = nlohmann::ordered_json::object();

tests/src/unit-element_access2.cpp

@@ -516,6 +516,21 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
                     CHECK(j_array.value("/-"_json_pointer, 42) == 42);
                     CHECK(j_array_const.value("/-"_json_pointer, 42) == 42);
 
+                    // Test an index with a non-digit after a valid leading digit; this is
+                    // out_of_range (not parse_error) and must not throw (see #5672)
+                    CHECK(j_array.value("/1a"_json_pointer, 42) == 42);
+                    CHECK(j_array_const.value("/1a"_json_pointer, 42) == 42);
+
+                    // Test the empty reference token (JSON pointer "/"); see #5672
+                    CHECK(j_array.value("/"_json_pointer, 42) == 42);
+                    CHECK(j_array_const.value("/"_json_pointer, 42) == 42);
+
+                    // Test an index whose magnitude does not fit into size_type (see #5672)
+                    CHECK(j_array.value("/99999999999999999999999"_json_pointer, 42) == 42);
+                    CHECK(j_array_const.value("/99999999999999999999999"_json_pointer, 42) == 42);
+                    CHECK(j_array.value("/18446744073709551615"_json_pointer, 42) == 42);
+                    CHECK(j_array_const.value("/18446744073709551615"_json_pointer, 42) == 42);
+
 #if !defined(JSON_NOEXCEPTION)
                     // Test malformed index (non-numeric) throws parse_error
                     CHECK_THROWS_WITH_AS(j_array.value("/foo"_json_pointer, 1), "[json.exception.parse_error.109] parse error: array index 'foo' is not a number", typename Json::parse_error&);