Fix ci_cuda_example CUDA 11.8 build after C++17 fallback (#3907)

The 11.8.0 leg's graceful C++17 fallback (added in the previous commit)
worked correctly, but the broadened smoke test used the <=> operator
unconditionally, which isn't valid syntax pre-C++20 — nvcc rejected it
with "expected an expression" once the CMake logic picked cuda_std_17
for the older toolkit. Gate those two lines behind
JSON_HAS_THREE_WAY_COMPARISON like the library itself does internally.

Sanity-compiled the file as plain C++ at both -std=c++17 (skips the
guarded block) and -std=c++20 (includes it) locally; the actual nvcc
build is verified via CI on PR #5248.

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

.github/workflows/ubuntu.yml

@@ -234,11 +234,22 @@ jobs:
 
   ci_cuda_example:
     runs-on: ubuntu-latest
-    container: ghcr.io/nlohmann/json-ci:v2.4.0
+    strategy:
+      fail-fast: false
+      matrix:
+        # 11.8.0: newest pre-C++20 CUDA release, exercises the C++17 fallback
+        # path (tests/cuda_example/CMakeLists.txt picks the standard per nvcc
+        # version); 12.1.1: permanent regression guard for #3907 (nvcc 12.0/12.1
+        # choke on enable_borrowed_range at C++20, fixed in 12.2); 12.6.3: recent
+        # CUDA/C++20 coverage.
+        cuda: ['11.8.0', '12.1.1', '12.6.3']
+    container: nvidia/cuda:${{ matrix.cuda }}-devel-ubuntu22.04
     steps:
       - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
+      - name: Get latest CMake and ninja
+        uses: lukka/get-cmake@f5b8fbb4d77cec1acc5a5f9f0df4beffaf5d98d9 # v4.3.4
       - name: Run CMake
         run: cmake -S . -B build -DJSON_CI=On
       - name: Build

cmake/ci.cmake

@@ -669,7 +669,6 @@ add_custom_target(ci_test_compiler_default
 add_custom_target(ci_cuda_example
     COMMAND ${CMAKE_COMMAND}
         -DCMAKE_BUILD_TYPE=Debug -GNinja
-        -DCMAKE_CUDA_HOST_COMPILER=g++-8
         -S${PROJECT_SOURCE_DIR}/tests/cuda_example -B${PROJECT_BINARY_DIR}/build_cuda_example
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_cuda_example
 )

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

@@ -82,13 +82,7 @@ basic_json(basic_json&& other) noexcept;
 4. This is a constructor for existing `basic_json` types. It does not hijack copy/move constructors, since the parameter
    has different template arguments than the current ones.
 
-    The constructor tries to convert the internal `m_value` of the parameter. Each member value (object, array, string,
+    The constructor tries to convert the internal `m_value` of the parameter.
-    etc.) is serialized via the corresponding `to_json()` overload. For objects and strings, the conversion requires
-    that the *target* `basic_json` type's `object_t::key_type` (or `string_t`) be directly constructible from the
-    *source* type's corresponding member type via `is_constructible`. If this requirement is not met, the conversion
-    does not fail to compile; instead, it silently falls back to the array-conversion path, which represents objects
-    as arrays of `[key, value]` pairs and strings as arrays of character codes. This is a known limitation tracked in
-    [issue #3425](https://github.com/nlohmann/json/issues/3425).
 
 5. Creates a JSON value of type array or object from the passed initializer list `init`. In case `type_deduction` is
    `#!cpp true` (default), the type of the JSON value to be created is deducted from the initializer list `init`
@@ -153,11 +147,6 @@ basic_json(basic_json&& other) noexcept;
     - `BasicJsonType` is a `basic_json` type.
     - `BasicJsonType` has different template arguments than `basic_json_t`.
 
-    **Note:** For cross-`basic_json` conversions to produce correct results, the target `basic_json`'s
-    `object_t::key_type` and `string_t` must be directly constructible from the source `basic_json`'s
-    corresponding types. See the description of overload (4) above for details on what happens when
-    this requirement is not met.
-
 `U`:
 :   `uncvref_t<CompatibleType>`
 

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

@@ -93,15 +93,6 @@ alphabetical order as `std::map` with `std::less` is used by default. Please not
 [RFC 8259](https://tools.ietf.org/html/rfc8259), because any order implements the specified "unordered" nature of JSON
 objects.
 
-#### Cross-`basic_json` conversion requirements
-
-When converting an object from one `basic_json` specialization to another via the
-[converting constructor](basic_json.md#overload-4), the target `object_t`'s `key_type` must be
-directly constructible from the source `basic_json`'s `string_t` type (or more generally, from the
-source object's key type). If this requirement is not met, the conversion does not fail; instead,
-the object is silently converted as an array of key-value pairs, which is incorrect. See
-[issue #3425](https://github.com/nlohmann/json/issues/3425) for details and an example.
-
 ## Examples
 
 ??? example

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

@@ -6,18 +6,9 @@ namespace std {
 }
 ```
 
-Return a hash value for a JSON object. The hash function tries to rely on `std::hash` where possible. To satisfy the
+Return a hash value for a JSON object. The hash function tries to rely on `std::hash` where possible. Furthermore, the
-`std::hash` contract, numeric JSON values that compare equal must hash to the same value. This means:
+type of the JSON value is taken into account to have different hash values for `#!json null`, `#!cpp 0`, `#!cpp 0U`, and
-
+`#!cpp false`, etc.
-- `json(42)`, `json(42u)`, and `json(42.0)` all hash to the same value
-- `json(0)`, `json(0u)`, and `json(0.0)` all hash to the same value
-
-Different types hash differently for non-numeric types (e.g., `#!json null`, `#!cpp false`, and strings all have distinct hashes).
-
-**Edge case:** For very large integers outside the exact representable range of the floating-point type (beyond ~2^53 for
-typical `double`), the hash values for integer and floating-point values may differ, even if the floating-point value
-was obtained by casting the integer (due to precision loss). This is a documented limitation arising from how the
-comparison operator normalizes numeric types.
 
 ## Examples
 

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

@@ -45,15 +45,6 @@ This implementation is interoperable as it does compare strings code unit by cod
 String values are stored as pointers in a `basic_json` type. That is, for any access to string values, a pointer of type
 `string_t*` must be dereferenced.
 
-#### Cross-`basic_json` conversion requirements
-
-When converting a string value from one `basic_json` specialization to another via the
-[converting constructor](basic_json.md#overload-4), the target `string_t` must be directly
-constructible from the source `basic_json`'s `string_t` type. If this requirement is not met, the
-conversion does not fail; instead, the string is silently converted as an array of character codes,
-which is incorrect. See [issue #3425](https://github.com/nlohmann/json/issues/3425) for details
-and an example.
-
 ## Examples
 
 ??? example

docs/mkdocs/docs/community/quality_assurance.md

@@ -62,7 +62,9 @@ violations will result in a failed build.
         | Clang 20.1.1                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | Clang 20.1.8 with GNU-like command-line      | x86_64       | Windows Server 2022 (Build 20348) | GitHub    |
         | Clang 21.1.8                                 | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | CUDA 11.0.221 (nvcc)                         | x86_64       | Ubuntu 20.04 LTS                  | GitHub    |
+        | CUDA 11.8.0 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
+        | CUDA 12.1.1 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
+        | CUDA 12.6.3 (nvcc)                           | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
         | Emscripten 4.0.6                             | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | GNU 4.8.5                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
         | GNU 4.9.3                                    | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |

docs/mkdocs/docs/examples/std_hash.cpp

@@ -11,7 +11,6 @@ int main()
               << "hash(false) = " << std::hash<json> {}(json(false)) << '\n'
               << "hash(0) = " << std::hash<json> {}(json(0)) << '\n'
               << "hash(0U) = " << std::hash<json> {}(json(0U)) << '\n'
-              << "hash(0.0) = " << std::hash<json> {}(json(0.0)) << '\n'
               << "hash(\"\") = " << std::hash<json> {}(json("")) << '\n'
               << "hash({}) = " << std::hash<json> {}(json::object()) << '\n'
               << "hash([]) = " << std::hash<json> {}(json::array()) << '\n'

docs/mkdocs/docs/examples/std_hash.output

@@ -1,9 +1,8 @@
 hash(null) = 2654435769
 hash(false) = 2654436030
-hash(0) = 2654436221
+hash(0) = 2654436095
-hash(0U) = 2654436221
+hash(0U) = 2654436156
-hash(0.0) = 2654436221
+hash("") = 6142509191626859748
-hash("") = 11160318156688833227
 hash({}) = 2654435832
 hash([]) = 2654435899
-hash({"hello": "world"}) = 3701319991624763853
+hash({"hello": "world"}) = 4469488738203676328

docs/mkdocs/docs/robots.txt

@@ -1,4 +0,0 @@
-User-agent: *
-Allow: /
-
-Sitemap: https://json.nlohmann.me/sitemap.xml

docs/mkdocs/hooks/copy_markdown_source.py

@@ -1,25 +0,0 @@
-"""Copy each documentation page's Markdown source into the built site."""
-
-# Creates a `<path>.md` sibling of each HTML output (for example,
-# `features/comments/` becomes `features/comments.md`) so agents and tools can
-# fetch the raw Markdown directly instead of parsing rendered HTML.
-
-import os
-import shutil
-
-_pages = []
-
-
-def on_files(files, config):
-    global _pages
-    _pages = [f for f in files if f.is_documentation_page()]
-    return files
-
-
-def on_post_build(config):
-    site_dir = config["site_dir"]
-    for file in _pages:
-        url = file.url.rstrip("/")
-        target = os.path.join(site_dir, (url or "index") + ".md")
-        os.makedirs(os.path.dirname(target), exist_ok=True)
-        shutil.copyfile(file.abs_src_path, target)

docs/mkdocs/mkdocs.yml

@@ -367,9 +367,6 @@ markdown_extensions:
       auto_append:
         - ../includes/glossary.md
 
-hooks:
-  - hooks/copy_markdown_source.py
-
 plugins:
   - search:
       separator: '[\s\-\.]'
@@ -392,33 +389,6 @@ plugins:
         - https://nlohmann.github.io/json/*
         - mailto:*
   - privacy
-  - llmstxt:
-      markdown_description: >
-        JSON for Modern C++ is a C++11 header-only library implementing a JSON
-        value type with an STL-like API, JSON Pointer/Patch, CBOR/MessagePack/
-        BSON/UBJSON/BJData binary format support, and a SAX-style parser interface.
-      sections:
-        Home:
-          - index.md
-          - home/*.md
-        Features:
-          - features/*.md
-          - features/binary_formats/*.md
-          - features/element_access/*.md
-          - features/parsing/*.md
-          - features/types/*.md
-        Integration:
-          - integration/*.md
-        API Documentation:
-          - api/*.md
-          - api/basic_json/*.md
-          - api/adl_serializer/*.md
-          - api/byte_container_with_subtype/*.md
-          - api/json_pointer/*.md
-          - api/json_sax/*.md
-          - api/macros/*.md
-        Community:
-          - community/*.md
 
 extra_css:
   - css/custom.css

docs/mkdocs/requirements.txt

@@ -7,6 +7,5 @@ mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
 mkdocs-redirects==1.2.3                             # plugin "redirects"
 mkdocs-htmlproofer-plugin==1.5.0                    # plugin "htmlproofer"
-mkdocs-llmstxt==0.5.0                               # plugin "llmstxt"
 
 PyYAML==6.0.3                                       # linter

include/nlohmann/detail/hash.hpp

@@ -11,8 +11,6 @@
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
-#include <limits> // numeric_limits
-#include <cmath> // isfinite
 
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -28,73 +26,12 @@ inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
     return seed;
 }
 
-// Check if a number_integer_t value is exactly representable as number_float_t
-// Returns true if static_cast<number_integer_t>(static_cast<number_float_t>(val)) == val
-template<typename BasicJsonType>
-inline bool is_exactly_representable_as_float(typename BasicJsonType::number_integer_t val) noexcept
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-
-    // If the float type's mantissa covers the integer type's entire range, all values round-trip
-    constexpr int float_digits = std::numeric_limits<number_float_t>::digits;
-    constexpr int int_digits = std::numeric_limits<number_integer_t>::digits;
-
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(push )
-#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
-#endif
-    if (float_digits >= int_digits)
-    {
-        return true;
-    }
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning( pop )
-#endif
-
-    // For values outside float's exact range, they don't round-trip
-    // The safe way to check: compute the max magnitude that round-trips
-    // Using unsigned arithmetic to avoid UB with negating INT_MIN
-
-    // Max magnitude representable exactly: 2^(digits-1) - 1 for signed, 2^digits - 1 for unsigned range
-    // But we're checking a signed value, so use 2^digits as the threshold
-    constexpr auto max_exact = static_cast<number_integer_t>(1) << (float_digits - 1);
-
-    // Check absolute value against this threshold
-    if (val >= 0)
-    {
-        if (val >= max_exact)
-        {
-            return false;
-        }
-    }
-    else
-    {
-        // For negative values, check via unsigned wrapping arithmetic
-        // -val in unsigned domain; if it wraps, the value is too negative
-        auto unsigned_abs = static_cast<typename BasicJsonType::number_unsigned_t>(-val);
-        if (unsigned_abs >= static_cast<typename BasicJsonType::number_unsigned_t>(max_exact))
-        {
-            return false;
-        }
-    }
-
-    // For values within the exact range, verify the round-trip
-    const auto f = static_cast<number_float_t>(val);
-    return std::isfinite(f) && static_cast<number_integer_t>(f) == val;
-}
-
 /*!
 @brief hash a JSON value
 
 The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
-most types. However, numeric types (number_integer, number_unsigned, number_float)
+null, 0, 0U, and false, etc.
-are hashed to satisfy the std::hash contract: if two json values compare equal,
-they must have equal hash values. This means json(42), json(42u), and json(42.0)
-all hash to the same value (since they compare equal). For large integer values
-outside the exact representable range of the float type, integer values are hashed
-in their own domain to avoid precision loss.
 
 @tparam BasicJsonType basic_json specialization
 @param j JSON value to hash
@@ -153,36 +90,14 @@ std::size_t hash(const BasicJsonType& j)
 
         case BasicJsonType::value_t::number_integer:
         {
-            const auto v = j.template get<number_integer_t>();
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
-            // Use a shared numeric type tag so all numeric types that are equal hash the same
+            return combine(type, h);
-            const auto numeric_type = static_cast<std::size_t>(BasicJsonType::value_t::number_float);
-
-            if (is_exactly_representable_as_float<BasicJsonType>(v))
-            {
-                const auto h = std::hash<number_float_t> {}(static_cast<number_float_t>(v));
-                return combine(numeric_type, h);
-            }
-
-            const auto h = std::hash<number_integer_t> {}(v);
-            return combine(numeric_type, h);
         }
 
         case BasicJsonType::value_t::number_unsigned:
         {
-            const auto v = j.template get<number_unsigned_t>();
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
-            // Normalize to signed (matching operator== behavior for U-vs-I comparison)
+            return combine(type, h);
-            const auto v_as_signed = static_cast<number_integer_t>(v);
-            // Use a shared numeric type tag so all numeric types that are equal hash the same
-            const auto numeric_type = static_cast<std::size_t>(BasicJsonType::value_t::number_float);
-
-            if (is_exactly_representable_as_float<BasicJsonType>(v_as_signed))
-            {
-                const auto h = std::hash<number_float_t> {}(static_cast<number_float_t>(v_as_signed));
-                return combine(numeric_type, h);
-            }
-
-            const auto h = std::hash<number_integer_t> {}(v_as_signed);
-            return combine(numeric_type, h);
         }
 
         case BasicJsonType::value_t::number_float:

include/nlohmann/detail/macro_scope.hpp

@@ -146,6 +146,11 @@
         #define JSON_HAS_RANGES 0
     #elif defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 160000
         #define JSON_HAS_RANGES 0
+        // nvcc CUDA 12.0/12.1 chokes on the enable_borrowed_range variable-template
+        // syntax when compiling as CUDA source; fixed in CUDA 12.2 (issue #3907)
+    #elif defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 12 \
+        && defined(__CUDACC_VER_MINOR__) && (__CUDACC_VER_MINOR__ == 0 || __CUDACC_VER_MINOR__ == 1)
+        #define JSON_HAS_RANGES 0
     #elif defined(__cpp_lib_ranges)
         #define JSON_HAS_RANGES 1
     #else

include/nlohmann/detail/output/serializer.hpp

@@ -465,12 +465,18 @@ class serializer
                             {
                                 if (codepoint <= 0xFFFF)
                                 {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
                                 }
                                 else
                                 {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
                                 }
                             }
                             else
@@ -677,32 +683,6 @@ class serializer
         return result;
     }
 
-    /*!
-     * @brief write a lowercase "\uXXXX" escape sequence into @a string_buffer
-     *
-     * Branch-free replacement for `snprintf(buf, 7, "\\u%04x", codeunit)` in the
-     * string escaping hot path. It writes exactly six characters ('\\', 'u' and
-     * four hex digits) at position @a pos of @a string_buffer via a nibble
-     * lookup table, avoiding the format-string parsing and locale machinery of
-     * `snprintf`. Advances @a pos by the number of bytes written (6).
-     *
-     * @param[in] pos       position in @a string_buffer to write at; there must
-     *                      be at least 6 bytes of headroom
-     * @param[in] codeunit  16-bit value to encode
-     */
-    void write_u_escape(std::size_t& pos, std::uint16_t codeunit) noexcept
-    {
-        JSON_ASSERT(string_buffer.size() - pos >= 6);
-        constexpr const char* nibble_to_hex = "0123456789abcdef";
-        string_buffer[pos + 0] = '\\';
-        string_buffer[pos + 1] = 'u';
-        string_buffer[pos + 2] = nibble_to_hex[(codeunit >> 12u) & 0x0Fu];
-        string_buffer[pos + 3] = nibble_to_hex[(codeunit >> 8u) & 0x0Fu];
-        string_buffer[pos + 4] = nibble_to_hex[(codeunit >> 4u) & 0x0Fu];
-        string_buffer[pos + 5] = nibble_to_hex[codeunit & 0x0Fu];
-        pos += 6;
-    }
-
     // templates to avoid warnings about useless casts
     template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
     bool is_negative_number(NumberType x)

single_include/nlohmann/json.hpp

@@ -2520,6 +2520,11 @@ JSON_HEDLEY_DIAGNOSTIC_POP
         #define JSON_HAS_RANGES 0
     #elif defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 160000
         #define JSON_HAS_RANGES 0
+        // nvcc CUDA 12.0/12.1 chokes on the enable_borrowed_range variable-template
+        // syntax when compiling as CUDA source; fixed in CUDA 12.2 (issue #3907)
+    #elif defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 12 \
+        && defined(__CUDACC_VER_MINOR__) && (__CUDACC_VER_MINOR__ == 0 || __CUDACC_VER_MINOR__ == 1)
+        #define JSON_HAS_RANGES 0
     #elif defined(__cpp_lib_ranges)
         #define JSON_HAS_RANGES 1
     #else
@@ -6677,8 +6682,6 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
-#include <limits> // numeric_limits
-#include <cmath> // isfinite
 
 // #include <nlohmann/detail/abi_macros.hpp>
 
@@ -6696,73 +6699,12 @@ inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
     return seed;
 }
 
-// Check if a number_integer_t value is exactly representable as number_float_t
-// Returns true if static_cast<number_integer_t>(static_cast<number_float_t>(val)) == val
-template<typename BasicJsonType>
-inline bool is_exactly_representable_as_float(typename BasicJsonType::number_integer_t val) noexcept
-{
-    using number_integer_t = typename BasicJsonType::number_integer_t;
-    using number_float_t = typename BasicJsonType::number_float_t;
-
-    // If the float type's mantissa covers the integer type's entire range, all values round-trip
-    constexpr int float_digits = std::numeric_limits<number_float_t>::digits;
-    constexpr int int_digits = std::numeric_limits<number_integer_t>::digits;
-
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(push )
-#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
-#endif
-    if (float_digits >= int_digits)
-    {
-        return true;
-    }
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning( pop )
-#endif
-
-    // For values outside float's exact range, they don't round-trip
-    // The safe way to check: compute the max magnitude that round-trips
-    // Using unsigned arithmetic to avoid UB with negating INT_MIN
-
-    // Max magnitude representable exactly: 2^(digits-1) - 1 for signed, 2^digits - 1 for unsigned range
-    // But we're checking a signed value, so use 2^digits as the threshold
-    constexpr auto max_exact = static_cast<number_integer_t>(1) << (float_digits - 1);
-
-    // Check absolute value against this threshold
-    if (val >= 0)
-    {
-        if (val >= max_exact)
-        {
-            return false;
-        }
-    }
-    else
-    {
-        // For negative values, check via unsigned wrapping arithmetic
-        // -val in unsigned domain; if it wraps, the value is too negative
-        auto unsigned_abs = static_cast<typename BasicJsonType::number_unsigned_t>(-val);
-        if (unsigned_abs >= static_cast<typename BasicJsonType::number_unsigned_t>(max_exact))
-        {
-            return false;
-        }
-    }
-
-    // For values within the exact range, verify the round-trip
-    const auto f = static_cast<number_float_t>(val);
-    return std::isfinite(f) && static_cast<number_integer_t>(f) == val;
-}
-
 /*!
 @brief hash a JSON value
 
 The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
-most types. However, numeric types (number_integer, number_unsigned, number_float)
+null, 0, 0U, and false, etc.
-are hashed to satisfy the std::hash contract: if two json values compare equal,
-they must have equal hash values. This means json(42), json(42u), and json(42.0)
-all hash to the same value (since they compare equal). For large integer values
-outside the exact representable range of the float type, integer values are hashed
-in their own domain to avoid precision loss.
 
 @tparam BasicJsonType basic_json specialization
 @param j JSON value to hash
@@ -6821,36 +6763,14 @@ std::size_t hash(const BasicJsonType& j)
 
         case BasicJsonType::value_t::number_integer:
         {
-            const auto v = j.template get<number_integer_t>();
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
-            // Use a shared numeric type tag so all numeric types that are equal hash the same
+            return combine(type, h);
-            const auto numeric_type = static_cast<std::size_t>(BasicJsonType::value_t::number_float);
-
-            if (is_exactly_representable_as_float<BasicJsonType>(v))
-            {
-                const auto h = std::hash<number_float_t> {}(static_cast<number_float_t>(v));
-                return combine(numeric_type, h);
-            }
-
-            const auto h = std::hash<number_integer_t> {}(v);
-            return combine(numeric_type, h);
         }
 
         case BasicJsonType::value_t::number_unsigned:
         {
-            const auto v = j.template get<number_unsigned_t>();
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
-            // Normalize to signed (matching operator== behavior for U-vs-I comparison)
+            return combine(type, h);
-            const auto v_as_signed = static_cast<number_integer_t>(v);
-            // Use a shared numeric type tag so all numeric types that are equal hash the same
-            const auto numeric_type = static_cast<std::size_t>(BasicJsonType::value_t::number_float);
-
-            if (is_exactly_representable_as_float<BasicJsonType>(v_as_signed))
-            {
-                const auto h = std::hash<number_float_t> {}(static_cast<number_float_t>(v_as_signed));
-                return combine(numeric_type, h);
-            }
-
-            const auto h = std::hash<number_integer_t> {}(v_as_signed);
-            return combine(numeric_type, h);
         }
 
         case BasicJsonType::value_t::number_float:
@@ -20047,12 +19967,18 @@ class serializer
                             {
                                 if (codepoint <= 0xFFFF)
                                 {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(codepoint));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
                                 }
                                 else
                                 {
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)));
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-                                    write_u_escape(bytes, static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
                                 }
                             }
                             else
@@ -20259,32 +20185,6 @@ class serializer
         return result;
     }
 
-    /*!
-     * @brief write a lowercase "\uXXXX" escape sequence into @a string_buffer
-     *
-     * Branch-free replacement for `snprintf(buf, 7, "\\u%04x", codeunit)` in the
-     * string escaping hot path. It writes exactly six characters ('\\', 'u' and
-     * four hex digits) at position @a pos of @a string_buffer via a nibble
-     * lookup table, avoiding the format-string parsing and locale machinery of
-     * `snprintf`. Advances @a pos by the number of bytes written (6).
-     *
-     * @param[in] pos       position in @a string_buffer to write at; there must
-     *                      be at least 6 bytes of headroom
-     * @param[in] codeunit  16-bit value to encode
-     */
-    void write_u_escape(std::size_t& pos, std::uint16_t codeunit) noexcept
-    {
-        JSON_ASSERT(string_buffer.size() - pos >= 6);
-        constexpr const char* nibble_to_hex = "0123456789abcdef";
-        string_buffer[pos + 0] = '\\';
-        string_buffer[pos + 1] = 'u';
-        string_buffer[pos + 2] = nibble_to_hex[(codeunit >> 12u) & 0x0Fu];
-        string_buffer[pos + 3] = nibble_to_hex[(codeunit >> 8u) & 0x0Fu];
-        string_buffer[pos + 4] = nibble_to_hex[(codeunit >> 4u) & 0x0Fu];
-        string_buffer[pos + 5] = nibble_to_hex[codeunit & 0x0Fu];
-        pos += 6;
-    }
-
     // templates to avoid warnings about useless casts
     template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
     bool is_negative_number(NumberType x)

tests/cuda_example/CMakeLists.txt

@@ -3,7 +3,18 @@ project(json_cuda LANGUAGES CUDA)
 
 add_executable(json_cuda json_cuda.cu)
 target_include_directories(json_cuda PRIVATE ../../include)
-target_compile_features(json_cuda PUBLIC cuda_std_11)
+
+# nvcc added C++20 support in CUDA 12.0 and C++17 in CUDA 11.0; pick the
+# newest standard the detected compiler actually supports (see #3907)
+# instead of hard-requiring one standard for every CUDA version.
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0)
+    set(json_cuda_std 20)
+elseif(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
+    set(json_cuda_std 17)
+else()
+    set(json_cuda_std 11)
+endif()
+target_compile_features(json_cuda PUBLIC cuda_std_${json_cuda_std})
 set_target_properties(json_cuda PROPERTIES
     CUDA_EXTENSIONS OFF
     CUDA_STANDARD_REQUIRED ON

tests/cuda_example/json_cuda.cu

@@ -16,4 +16,20 @@ int main()
     // regression for #3013 (ordered_json::reset() compile error with nvcc)
     nlohmann::ordered_json metadata;
     metadata.erase("key");
+
+    // exercise comparisons (operator==/operator<=>, gated by
+    // JSON_HAS_THREE_WAY_COMPARISON, independent of JSON_HAS_RANGES) and
+    // range-based iteration (exercises iteration_proxy/ranges machinery
+    // beyond just the enable_borrowed_range specialization) — see #3907
+    nlohmann::json a = {1, 2, 3};
+    nlohmann::json b = {1, 2, 3};
+    static_cast<void>(a == b);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    static_cast<void>(a <=> b); // *NOPAD*
+    static_cast<void>(a <=> 1); // *NOPAD*
+#endif
+    for (const auto& element : a)
+    {
+        static_cast<void>(element);
+    }
 }

tests/src/unit-alt-string.cpp

@@ -322,12 +322,14 @@ TEST_CASE("alternative string type")
 
     SECTION("JSON pointer")
     {
-        // Direct conversion from a json literal to alt_json is not supported due to issue #3425:
+        // conversion from json to alt_json fails to compile (see #3425);
-        // alt_json's string_t (alt_string) is not directly constructible from std::string, so the
+        // attempted fix(*) produces: [[['b','a','r'],['b','a','z']]] (with each char being an integer)
-        // cross-basic_json conversion falls back to the array-conversion path, incorrectly representing
+        // (*) disable implicit conversion for json_refs of any basic_json type
-        // objects as arrays of [key, value] pairs and strings as arrays of character codes.
+        // alt_json j = R"(
-        // See https://github.com/nlohmann/json/issues/3425 for details.
+        // {
-        // Workaround: use alt_json::parse() instead of implicit conversion.
+        //     "foo": ["bar", "baz"]
+        // }
+        // )"_json;
         auto j = alt_json::parse(R"({"foo": ["bar", "baz"]})");
 
         CHECK(j.at(alt_json::json_pointer("/foo/0")) == j["foo"][0]);

tests/src/unit-convenience.cpp

@@ -168,32 +168,6 @@ TEST_CASE("convenience functions")
         CHECK_THROWS_WITH_AS(check_escaped("\xC2"), "[json.exception.type_error.316] incomplete UTF-8 string; last byte: 0xC2", json::type_error&);
     }
 
-    SECTION("string escape with ensure_ascii")
-    {
-        // control characters are escaped regardless of ensure_ascii
-        check_escaped("\x01", "\\u0001", true);
-        check_escaped("\x1f", "\\u001f", true);
-
-        // non-ASCII code points in the Basic Multilingual Plane are emitted as
-        // a single lowercase \uXXXX escape (exercises every nibble position)
-        check_escaped("\xC2\x80", "\\u0080", true);         // U+0080
-        check_escaped("\xC3\xBF", "\\u00ff", true);         // U+00FF (ÿ)
-        check_escaped("\xDF\xBF", "\\u07ff", true);         // U+07FF
-        check_escaped("\xE4\xBD\xA0", "\\u4f60", true);     // U+4F60 (你)
-        check_escaped("\xEA\xAF\x8D", "\\uabcd", true);     // U+ABCD
-        check_escaped("\xEF\xBF\xBD", "\\ufffd", true);     // U+FFFD (replacement char, all-f nibbles)
-
-        // code points outside the BMP are emitted as a UTF-16 surrogate pair
-        // of two lowercase \uXXXX escapes
-        check_escaped("\xF0\x90\x80\x80", "\\ud800\\udc00", true); // U+10000 (lowest astral)
-        check_escaped("\xF0\x9F\x98\x80", "\\ud83d\\ude00", true); // U+1F600 (😀)
-        check_escaped("\xF4\x8F\xBF\xBF", "\\udbff\\udfff", true); // U+10FFFF (highest code point)
-
-        // with ensure_ascii disabled, non-ASCII input is passed through verbatim
-        check_escaped("\xE4\xBD\xA0", "\xE4\xBD\xA0", false);
-        check_escaped("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", false);
-    }
-
     SECTION("string concat")
     {
         using nlohmann::detail::concat;

tests/src/unit-hash.cpp

@@ -35,10 +35,10 @@ TEST_CASE("hash<nlohmann::json>")
 
     // number
     hashes.insert(std::hash<json> {}(json(0)));
-    hashes.insert(std::hash<json> {}(json(static_cast<unsigned>(0)))); // now same hash as json(0)
+    hashes.insert(std::hash<json> {}(json(static_cast<unsigned>(0))));
-    hashes.insert(std::hash<json> {}(json(0.0)));                       // now same hash as json(0)
 
     hashes.insert(std::hash<json> {}(json(-1)));
+    hashes.insert(std::hash<json> {}(json(0.0)));
     hashes.insert(std::hash<json> {}(json(42.23)));
 
     // array
@@ -60,16 +60,7 @@ TEST_CASE("hash<nlohmann::json>")
     // discarded
     hashes.insert(std::hash<json> {}(json(json::value_t::discarded)));
 
-    // Note: json(0), json(0U), and json(0.0) now hash to the same value
+    CHECK(hashes.size() == 21);
-    // (to satisfy the std::hash contract: equal values must hash equally)
-    // So we expect 19 distinct hashes instead of 21
-    CHECK(hashes.size() == 19);
-
-    // Verify the std::hash contract: equal values must hash equally
-    CHECK(std::hash<json> {}(json(0)) == std::hash<json> {}(json(static_cast<unsigned>(0))));
-    CHECK(std::hash<json> {}(json(0)) == std::hash<json> {}(json(0.0)));
-    CHECK(std::hash<json> {}(json(42)) == std::hash<json> {}(json(42u)));
-    CHECK(std::hash<json> {}(json(42)) == std::hash<json> {}(json(42.0)));
 }
 
 TEST_CASE("hash<nlohmann::ordered_json>")
@@ -93,10 +84,10 @@ TEST_CASE("hash<nlohmann::ordered_json>")
 
     // number
     hashes.insert(std::hash<ordered_json> {}(ordered_json(0)));
-    hashes.insert(std::hash<ordered_json> {}(ordered_json(static_cast<unsigned>(0)))); // now same hash as ordered_json(0)
+    hashes.insert(std::hash<ordered_json> {}(ordered_json(static_cast<unsigned>(0))));
-    hashes.insert(std::hash<ordered_json> {}(ordered_json(0.0)));                       // now same hash as ordered_json(0)
 
     hashes.insert(std::hash<ordered_json> {}(ordered_json(-1)));
+    hashes.insert(std::hash<ordered_json> {}(ordered_json(0.0)));
     hashes.insert(std::hash<ordered_json> {}(ordered_json(42.23)));
 
     // array
@@ -118,12 +109,5 @@ TEST_CASE("hash<nlohmann::ordered_json>")
     // discarded
     hashes.insert(std::hash<ordered_json> {}(ordered_json(ordered_json::value_t::discarded)));
 
-    // Note: ordered_json(0), ordered_json(0U), and ordered_json(0.0) now hash to the same value
+    CHECK(hashes.size() == 21);
-    CHECK(hashes.size() == 19);
-
-    // Verify the std::hash contract for ordered_json as well
-    CHECK(std::hash<ordered_json> {}(ordered_json(0)) == std::hash<ordered_json> {}(ordered_json(static_cast<unsigned>(0))));
-    CHECK(std::hash<ordered_json> {}(ordered_json(0)) == std::hash<ordered_json> {}(ordered_json(0.0)));
-    CHECK(std::hash<ordered_json> {}(ordered_json(42)) == std::hash<ordered_json> {}(ordered_json(42u)));
-    CHECK(std::hash<ordered_json> {}(ordered_json(42)) == std::hash<ordered_json> {}(ordered_json(42.0)));
 }