Route hand-rolled diagnostic pragmas through Hedley

Several places in the library hand-roll compiler diagnostic suppression
with raw `#pragma`/`#ifdef __GNUC__`/`#ifdef __clang__` guards instead of
using the Hedley primitives already bundled and used elsewhere
(JSON_HEDLEY_DIAGNOSTIC_PUSH/POP, JSON_HEDLEY_PRAGMA, ...). Converted six
of the seven listed push/pop pairs to use those primitives instead of
raw `#pragma GCC diagnostic`/`#pragma clang diagnostic` text:

- include/nlohmann/json.hpp (~3770, ~3863): -Wfloat-equal
- include/nlohmann/detail/conversions/to_chars.hpp (~1078): -Wfloat-equal
- include/nlohmann/detail/output/binary_writer.hpp (~1844): -Wfloat-equal
- include/nlohmann/detail/iterators/iteration_proxy.hpp (~211): -Wmismatched-tags
- include/nlohmann/detail/exceptions.hpp (~36): -Wweak-vtables

iteration_proxy.hpp did not previously include macro_scope.hpp itself
(it only compiled because some other header included earlier in
json.hpp happened to pull macro_scope.hpp in first); it now includes it
directly like the other detail headers that use Hedley macros, so it is
self-contained.

Each push/pop pair now uses JSON_HEDLEY_DIAGNOSTIC_PUSH/POP
unconditionally (a no-op on compilers that don't need it) and wraps the
actual `#pragma ... diagnostic ignored` text in JSON_HEDLEY_PRAGMA so it
goes through Hedley's _Pragma()-based emission instead of a raw #pragma
line, while keeping the original `#ifdef __GNUC__` / `#if
defined(__clang__)` guard around the ignored-pragma itself.

Deviation from the issue's suggested transformation: the issue's example
replaces the `#ifdef __GNUC__` guard with `#if
JSON_HEDLEY_HAS_WARNING("-Wfloat-equal")`. JSON_HEDLEY_HAS_WARNING is
implemented purely via Clang's `__has_warning` builtin and evaluates to
0 on real GCC (`#define JSON_HEDLEY_HAS_WARNING(warning) (0)` when
`__has_warning` is not defined), so adopting it verbatim would silently
stop suppressing -Wfloat-equal on GCC -- a real regression, not just a
style change. The existing `#ifdef __GNUC__` / `#if defined(__clang__)`
guards were kept for the ignored-pragma to stay behavior-preserving, and
only the push/pop/pragma-emission mechanism was routed through Hedley.

Two of the seven locations from the issue (the -Wignored-attributes
push at the very top of json.hpp and its matching pop after
`#include <nlohmann/detail/macro_unscope.hpp>`) were intentionally left
unconverted:
- The push, at the very top of json.hpp, runs before
  `detail/macro_scope.hpp` (and therefore hedley.hpp) has been included
  anywhere in the translation unit, so JSON_HEDLEY_DIAGNOSTIC_PUSH is not
  yet defined at that point.
- The pop runs after `macro_unscope.hpp`, which -- via hedley_undef.hpp
  -- has already #undef'd every JSON_HEDLEY_* macro (by design, see
  #5408) precisely so they don't leak to users, so JSON_HEDLEY_DIAGNOSTIC_POP
  is no longer defined by the time the pop is reached either.
  Making this one pair work would require either hoisting the ~2000
  line vendored hedley.hpp to the very top of the amalgamated single
  header (a much bigger structural change to single_include than a pure
  mechanism swap) or special-casing this one pop ahead of the general
  macro cleanup. Both are riskier than the mechanical, behavior-preserving
  change requested, so this pair was left as-is.

## Validation

- Compiled include/nlohmann/json.hpp and single_include/nlohmann/json.hpp
  with `-Wall -Wextra -Wfloat-equal -Wmismatched-tags -Wweak-vtables`
  (clang, which self-identifies as __GNUC__ too): no warnings, same as
  before the change.
- Compiled and ran tests/src/unit-to_chars.cpp, unit-conversions.cpp,
  unit-iterators1.cpp, unit-iterators2.cpp, and unit-class_parser.cpp
  against the fixed include/: all pass.
- Compiled unit-msgpack.cpp, unit-bjdata.cpp, and unit-ubjson.cpp (which
  exercise binary_writer.hpp's write_compact_float extensively): all
  compile cleanly; the vast majority of assertions pass (the only
  failures are pre-existing environment issues unrelated to this change
  -- missing generated test-data files, not code correctness).
- Ran `make amalgamate`; the single_include diff is limited to exactly
  the lines touched in include/, with no unrelated reordering.
- No real (non-Apple) GCC was available in this environment to test
  directly; the `_Pragma("GCC diagnostic ...")` text emitted by
  JSON_HEDLEY_PRAGMA is byte-identical to the prior `#pragma GCC
  diagnostic ...` text, and the `#ifdef __GNUC__` guard is unchanged, so
  GCC's behavior is expected to be identical. CI covers the GCC matrix.

This PR is stacked on top of #5475 (issue-5408-hedley-undef-leak) since
both touch the same files; only the last commit here is new.

Fixes #5409.

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

Makefile

@@ -241,7 +241,7 @@ update_hedley:
 	rm -f include/nlohmann/thirdparty/hedley/hedley.hpp include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	curl https://raw.githubusercontent.com/nemequ/hedley/master/hedley.h -o include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i 's/HEDLEY_/JSON_HEDLEY_/g' include/nlohmann/thirdparty/hedley/hedley.hpp
-	grep "[[:blank:]]*#[[:blank:]]*undef" include/nlohmann/thirdparty/hedley/hedley.hpp | grep -v "__" | sort | uniq | $(SED) 's/ //g' | $(SED) 's/undef/undef /g' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
+	grep -oE "#[[:blank:]]*define[[:blank:]]+JSON_HEDLEY_[A-Za-z0-9_]+" include/nlohmann/thirdparty/hedley/hedley.hpp | awk '{print $$NF}' | grep -v "__" | sort -u | $(SED) 's/^/#undef /' > include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley.hpp
 	$(SED) -i '1s/^/#pragma once\n\n/' include/nlohmann/thirdparty/hedley/hedley_undef.hpp
 	$(MAKE) amalgamate

docs/mkdocs/docs/features/binary_formats/ubjson.md

@@ -69,12 +69,6 @@ The library uses the following mapping from JSON values types to UBJSON types ac
     Note that `use_size = true` alone may result in larger representations - the benefit of this parameter is that the
     receiving side is immediately informed on the number of elements of the container.
 
-    An array whose type marker is `Z` (null), `T` (true) or `F` (false) stores no payload at all, because the marker
-    already is the value. Its declared count is therefore the only thing that decides how much memory the receiving side
-    allocates, and a handful of bytes can describe billions of elements. `from_ubjson` rejects such an array with
-    [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408) when the count exceeds 1,048,576, and
-    `to_ubjson` writes longer arrays of these types without the annotation, so any value it produces can be read back.
-
 !!! info "Binary values"
 
     If the JSON data contains the binary type, the value stored is a list of integers, as suggested by the UBJSON

docs/mkdocs/docs/home/exceptions.md

@@ -868,12 +868,6 @@ The size of an array or object in a [binary format](../features/binary_formats/i
 the size following `#` for [UBJSON](../features/binary_formats/ubjson.md)/[BJData](../features/binary_formats/bjdata.md),
 or the encoded length for [CBOR](../features/binary_formats/cbor.md).
 
-The exception is also thrown for a [UBJSON](../features/binary_formats/ubjson.md) array of a type that is encoded by its
-marker alone (`Z`, `T` or `F`) whose declared count exceeds 1,048,576. Such an array has no payload, so its count alone
-decides how much memory is allocated, and a handful of bytes would otherwise describe billions of values.
-[`to_ubjson`](../api/basic_json/to_ubjson.md) writes longer arrays of these types without the size and type annotation,
-so any value it produces can still be read back.
-
 !!! failure "Example messages"
 
     ```
@@ -885,9 +879,6 @@ so any value it produces can still be read back.
     ```
     [json.exception.out_of_range.408] syntax error while parsing CBOR size: excessive map size
     ```
-    ```
-    [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size
-    ```
 
 ### json.exception.out_of_range.409
 

include/nlohmann/detail/conversions/to_chars.hpp

@@ -1074,9 +1074,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '-';
     }
 
+    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
-#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
     if (value == 0) // +-0
     {
@@ -1086,9 +1086,7 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '0';
         return first;
     }
-#ifdef __GNUC__
+    JSON_HEDLEY_DIAGNOSTIC_POP
-#pragma GCC diagnostic pop
-#endif
 
     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
 

include/nlohmann/detail/exceptions.hpp

@@ -32,9 +32,9 @@
 // functions to. As a result, we suppress this warning here to avoid client
 // code stumbling over this. See https://github.com/nlohmann/json/issues/4087
 // for a discussion.
+JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    #pragma clang diagnostic push
+    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
-    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -286,6 +286,4 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-#if defined(__clang__)
+JSON_HEDLEY_DIAGNOSTIC_POP
-    #pragma clang diagnostic pop
-#endif

include/nlohmann/detail/iterators/iteration_proxy.hpp

@@ -18,6 +18,7 @@
 #endif
 
 #include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>
@@ -206,10 +207,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 
+// Fix: https://github.com/nlohmann/json/issues/1401
+JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    // Fix: https://github.com/nlohmann/json/issues/1401
+    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
 template<typename IteratorType>
 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
@@ -223,9 +224,7 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                      get<N>(std::declval <
                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-#if defined(__clang__)
+JSON_HEDLEY_DIAGNOSTIC_POP
-    #pragma clang diagnostic pop
-#endif
 
 }  // namespace std
 

include/nlohmann/detail/output/binary_writer.hpp

@@ -826,17 +826,7 @@ class binary_writer
 
                     std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
 
-                    // an optimized array of a valueless type carries no payload, so a
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
-                    // reader has nothing but the declared count to bound the allocation
-                    // by and refuses an excessive one. Write the unoptimized form for
-                    // those, at one byte per element, so the result can be read back.
-                    // Objects are not affected: every element is preceded by its key.
-                    const bool valueless_type = (first_prefix == 'Z' || first_prefix == 'T' || first_prefix == 'F');
-                    const bool excessive_valueless = valueless_type
-                                                     && j.m_data.m_value.array->size() > detail::max_valueless_container_size;
-
-                    if (same_prefix && !excessive_valueless
-                            && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
                     {
                         prefix_required = false;
                         oa->write_character(to_char_type('$'));
@@ -1859,9 +1849,9 @@ class binary_writer
 
     void write_compact_float(const number_float_t n, detail::input_format_t format)
     {
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
-#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
                                    static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
@@ -1879,9 +1869,7 @@ class binary_writer
                                 : get_msgpack_float_prefix(n));
             write_number(n);
         }
-#ifdef __GNUC__
+        JSON_HEDLEY_DIAGNOSTIC_POP
-#pragma GCC diagnostic pop
-#endif
     }
 
   public:

include/nlohmann/json.hpp

@@ -3769,15 +3769,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     bool operator==(const_reference rhs) const noexcept
     {
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
-#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         const_reference lhs = *this;
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-#ifdef __GNUC__
+        JSON_HEDLEY_DIAGNOSTIC_POP
-#pragma GCC diagnostic pop
-#endif
     }
 
     /// @brief comparison: equal
@@ -3862,14 +3860,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
     friend bool operator==(const_reference lhs, const_reference rhs) noexcept
     {
+        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-#pragma GCC diagnostic push
+        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
-#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-#ifdef __GNUC__
+        JSON_HEDLEY_DIAGNOSTIC_POP
-#pragma GCC diagnostic pop
-#endif
     }
 
     /// @brief comparison: equal
@@ -4473,11 +4469,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in CBOR format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4493,11 +4486,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     template<typename T>
@@ -4522,11 +4512,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = i.get();
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in MessagePack format
@@ -4540,11 +4527,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in MessagePack format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4559,11 +4543,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     template<typename T>
@@ -4586,11 +4567,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = i.get();
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in UBJSON format
@@ -4604,11 +4582,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in UBJSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4623,11 +4598,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     template<typename T>
@@ -4650,11 +4622,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = i.get();
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in BJData format
@@ -4668,11 +4637,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in BJData format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4687,11 +4653,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in BSON format
@@ -4705,11 +4668,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     /// @brief create a JSON value from an input in BSON format (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -4724,11 +4684,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         basic_json result;
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
 
     template<typename T>
@@ -4751,11 +4708,8 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         auto ia = i.get();
         detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-        if (!binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict)) // cppcheck-suppress[accessMoved]
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
-        {
+        return res ? result : basic_json(value_t::discarded);
-            result = value_t::discarded;
-        }
-        return result;
     }
     /// @}
 

include/nlohmann/thirdparty/hedley/hedley_undef.hpp

@@ -17,7 +17,7 @@
 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,7 +108,10 @@
 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 #undef JSON_HEDLEY_PGI_VERSION
 #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PRAGMA
 #undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PREDICT_FALSE
+#undef JSON_HEDLEY_PREDICT_TRUE
 #undef JSON_HEDLEY_PRINTF_FORMAT
 #undef JSON_HEDLEY_PRIVATE
 #undef JSON_HEDLEY_PUBLIC

tests/src/unit-bjdata.cpp

@@ -3288,10 +3288,8 @@ TEST_CASE("BJData")
             CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR1), "[json.exception.parse_error.113] parse error at byte 6: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
             CHECK(json::from_bjdata(vR1, true, false).is_discarded());
 
-            // a dimension vector that opens another one is rejected where the
-            // nested '[' is read, rather than after it has been descended into
             std::vector<uint8_t> const vR2 = {'[', '$', 'i', '#', '[', '#', '[', 'i', 1, ']', ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 7: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR2), "[json.exception.parse_error.113] parse error at byte 11: syntax error while parsing BJData size: expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x5D", json::parse_error&);
             CHECK(json::from_bjdata(vR2, true, false).is_discarded());
 
             std::vector<uint8_t> const vR3 = {'[', '#', '[', 'i', '2', 'i', 2, ']'};
@@ -3299,7 +3297,7 @@ TEST_CASE("BJData")
             CHECK(json::from_bjdata(vR3, true, false).is_discarded());
 
             std::vector<uint8_t> const vR4 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', 1, ']', 1};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR4), "[json.exception.parse_error.110] parse error at byte 14: syntax error while parsing BJData number: unexpected end of input", json::parse_error&);
             CHECK(json::from_bjdata(vR4, true, false).is_discarded());
 
             std::vector<uint8_t> const vR5 = {'[', '$', 'i', '#', '[', '[', '[', ']', ']', ']'};
@@ -3307,25 +3305,12 @@ TEST_CASE("BJData")
             CHECK(json::from_bjdata(vR5, true, false).is_discarded());
 
             std::vector<uint8_t> const vR6 = {'[', '$', 'i', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.113] parse error at byte 9: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
+            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vR6), "[json.exception.parse_error.112] parse error at byte 14: syntax error while parsing BJData size: ndarray can not be recursive", json::parse_error&);
             CHECK(json::from_bjdata(vR6, true, false).is_discarded());
 
             std::vector<uint8_t> const vH = {'[', 'H', '[', '#', '[', '$', 'i', '#', '[', 'i', '2', 'i', 2, ']'};
             CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vH), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
             CHECK(json::from_bjdata(vH, true, false).is_discarded());
-
-            // Every "#[" of this chain used to open another dimension vector
-            // and cost several stack frames before anything was rejected, so a
-            // long enough chain crashed the process (see #5104). The nested
-            // vector is refused where it is read, so the length is irrelevant.
-            std::vector<uint8_t> vRdeep = {'['};
-            for (std::size_t i = 0; i < 100000; ++i)
-            {
-                vRdeep.push_back('#');
-                vRdeep.push_back('[');
-            }
-            CHECK_THROWS_WITH_AS(_ = json::from_bjdata(vRdeep), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing BJData size: ndarray dimensional vector is not allowed", json::parse_error&);
-            CHECK(json::from_bjdata(vRdeep, true, false).is_discarded());
         }
 
         SECTION("objects")

tests/src/unit-bson.cpp

@@ -1011,76 +1011,6 @@ TEST_CASE("BSON document size mismatch")
     }
 }
 
-TEST_CASE("BSON nesting does not consume the call stack")
-{
-    // An embedded document or array used to be read by calling back into the
-    // document reader, so the native call stack grew with the nesting depth of
-    // the input (#5104). The open documents are kept on a heap stack now.
-    //
-    // Deeply nested values must not be compared, copied or dumped here: those
-    // operations are still recursive and would reintroduce the crash.
-
-    // a document nested deeply enough to have crashed, built by to_bson so
-    // that every one of its size prefixes is correct
-    const std::size_t depth = 30000;
-    json deep = json::object();
-    json* p = &deep;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        (*p)["a"] = json::object();
-        p = &(*p)["a"];
-    }
-    const std::vector<uint8_t> input = json::to_bson(deep);
-
-    SECTION("a well-formed deep document is read through the SAX interface")
-    {
-        SaxCountdown accept_all(1000000);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::bson));
-    }
-
-    SECTION("a well-formed deep document is read into a value")
-    {
-        json j = json::from_bson(input);
-
-        std::size_t measured = 0;
-        const json* q = &j;
-        while (q->is_object() && !q->empty())
-        {
-            q = &q->begin().value();
-            ++measured;
-        }
-        CHECK(measured == depth);
-    }
-
-    SECTION("embedded documents and arrays are still read the same way")
-    {
-        const json values = {{"a", {{"b", {{"c", 1}}}}}};
-        CHECK(json::from_bson(json::to_bson(values)) == values);
-
-        const json array = {{"a", {1, 2, 3}}};
-        CHECK(json::from_bson(json::to_bson(array)) == array);
-
-        const json mixed = {{"a", {json{{"x", 1}}, json{{"y", 2}}}}};
-        CHECK(json::from_bson(json::to_bson(mixed)) == mixed);
-
-        CHECK(json::from_bson(json::to_bson(json::object())) == json::object());
-    }
-
-    SECTION("a size that does not match is still reported per document")
-    {
-        // the embedded document claims one byte too many
-        std::vector<uint8_t> const bad =
-        {
-            0x15, 0x00, 0x00, 0x00, 0x03, 'a', 0x00,
-            0x0D, 0x00, 0x00, 0x00, 0x08, 'b', 0x00, 0x01, 0x00,
-            0x00
-        };
-        json _;
-        CHECK_THROWS_AS(_ = json::from_bson(bad), json::parse_error&);
-        CHECK(json::from_bson(bad, true, false).is_discarded());
-    }
-}
-
 TEST_CASE("BSON numerical data")
 {
     SECTION("number")

tests/src/unit-cbor.cpp

@@ -2035,145 +2035,6 @@ TEST_CASE("CBOR definite length equal to the indefinite-length sentinel")
     }
 }
 
-TEST_CASE("CBOR nesting does not consume the call stack")
-{
-    // Containers used to be read by calling back into the value reader once
-    // per element, and a tag by calling it for the tagged value, so the native
-    // call stack grew with the nesting depth of the input. Each of the three
-    // costs a single byte to encode -- 0x9F, 0x81 and 0xC2 -- so a payload of
-    // repeated bytes crashed the process (#5104). The containers are kept on a
-    // heap stack now, and a tag is read in a loop.
-    //
-    // Deeply nested values must not be compared, copied or dumped here: those
-    // operations are still recursive and would reintroduce the crash.
-    json _;
-
-    SECTION("indefinite-length containers")
-    {
-        const std::vector<uint8_t> input(500000, 0x9F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("definite-length containers")
-    {
-        const std::vector<uint8_t> input(500000, 0x81);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("tags")
-    {
-        // a tag is not a value of its own, so a chain of them used to recurse
-        const std::vector<uint8_t> input(500000, 0xC2);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input, true, true, json::cbor_tag_handler_t::ignore), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false, json::cbor_tag_handler_t::ignore).is_discarded());
-    }
-
-    SECTION("a well-formed deep value is read through the SAX interface")
-    {
-        std::vector<uint8_t> input(200000, 0x9F);
-        input.insert(input.end(), 200000, 0xFF);
-
-        SaxCountdown accept_all(1000000);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::cbor));
-    }
-
-    SECTION("a well-formed deep value is read into a value")
-    {
-        const std::size_t depth = 10000;
-        std::vector<uint8_t> input(depth, 0x81);
-        input.push_back(0x00);
-
-        json j = json::from_cbor(input);
-
-        std::size_t measured = 0;
-        const json* p = &j;
-        while (p->is_array() && !p->empty())
-        {
-            p = &p->front();
-            ++measured;
-        }
-        CHECK(measured == depth);
-        CHECK(p->is_number());
-    }
-
-    SECTION("containers are still read the same way")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x80})) == json::array());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xA0})) == json::object());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0xFF})) == json::array());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0xFF})) == json::object());
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x01, 0x02, 0xFF})) == json({1, 2}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xBF, 0x61, 'a', 0x01, 0xFF})) == json({{"a", 1}}));
-        // definite and indefinite forms nested inside each other
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x9F, 0x82, 0x01, 0x02, 0xA1, 0x61, 'k', 0xBF, 0xFF, 0xFF})) == json({{1, 2}, {{"k", json::object()}}}));
-    }
-
-    SECTION("tagged values are still read the same way")
-    {
-        const auto ignore = json::cbor_tag_handler_t::ignore;
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x01}), true, true, ignore) == json(1));
-        // a chain of tags resolves to the value that follows it
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0xC2, 0xC2, 0x01}), true, true, ignore) == json(1));
-        // a tag inside a container, and one in front of a container
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x82, 0xC2, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xC2, 0x82, 0x01, 0x02}), true, true, ignore) == json({1, 2}));
-    }
-}
-
-TEST_CASE("CBOR indefinite-length strings do not recurse per chunk")
-{
-    // Reading an indefinite-length string or byte array used to call itself
-    // once per chunk, so a payload of repeated 0x7F (or 0x5F) bytes exhausted
-    // the call stack before any of the input was rejected. The open levels are
-    // counted now, and the levels below prove the reader still reads the same
-    // values and reports the same errors at the same byte offsets.
-    json _;
-
-    SECTION("many open levels are reported, not crashed on")
-    {
-        const std::vector<uint8_t> input(200000, 0x7F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR string: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("many open levels are reported, not crashed on (binary)")
-    {
-        const std::vector<uint8_t> input(200000, 0x5F);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(input), "[json.exception.parse_error.110] parse error at byte 200001: syntax error while parsing CBOR binary: unexpected end of input", json::parse_error&);
-        CHECK(json::from_cbor(input, true, false).is_discarded());
-    }
-
-    SECTION("chunks are still concatenated")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0xFF})) == json(""));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x61, 0x61, 0xFF})) == json("a"));
-        // nested indefinite-length strings are concatenated across levels
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x61, 0x61, 0xFF, 0x61, 0x62, 0xFF})) == json("ab"));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x7F, 0x61, 0x7A, 0xFF, 0xFF, 0xFF})) == json("z"));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0xA1, 0x7F, 0x61, 0x61, 0xFF, 0x01})) == json({{"a", 1}}));
-    }
-
-    SECTION("chunks are still concatenated (binary)")
-    {
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x41, 0x61, 0xFF})) == json::binary({0x61}));
-        CHECK(json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x41, 0x61, 0xFF, 0x41, 0x62, 0xFF})) == json::binary({0x61, 0x62}));
-    }
-
-    SECTION("a chunk that is not a string is still rejected")
-    {
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x7F, 0x7F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x00", json::parse_error&);
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x5F, 0x5F, 0x00})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR binary: expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x00", json::parse_error&);
-    }
-
-    SECTION("a break marker outside an indefinite-length string is not a string")
-    {
-        // 0xFF only closes a string that was opened; on its own it is not one
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0xA1, 0xFF, 0x01})), "[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xFF", json::parse_error&);
-    }
-}
-
 TEST_CASE("CBOR roundtrips" * doctest::skip())
 {
     SECTION("input from flynn")

tests/src/unit-msgpack.cpp

@@ -1598,67 +1598,6 @@ TEST_CASE("MessagePack")
 }
 
 // use this testcase outside [hide] to run it with Valgrind
-TEST_CASE("MessagePack nesting does not consume the call stack")
-{
-    // Reading a container used to call back into the value reader once per
-    // element, so the native call stack grew with the nesting depth of the
-    // input: one frame per byte for repeated 0x91 (a one-element array), which
-    // crashes the process long before the input is exhausted (#5104). The
-    // containers are kept on a heap stack now.
-    //
-    // Note that deeply nested values must not be compared, copied or dumped
-    // here: those operations are still recursive, and would reintroduce the
-    // very crash this checks for. Depth is measured by descending instead.
-
-    SECTION("an unterminated chain is reported, not crashed on")
-    {
-        json _;
-        const std::vector<uint8_t> input(300000, 0x91);
-        CHECK_THROWS_WITH_AS(_ = json::from_msgpack(input), "[json.exception.parse_error.110] parse error at byte 300001: syntax error while parsing MessagePack value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_msgpack(input, true, false).is_discarded());
-    }
-
-    SECTION("a well-formed deep value is read through the SAX interface")
-    {
-        std::vector<uint8_t> input(300000, 0x91);
-        input.push_back(0x01); // innermost value
-
-        SaxCountdown accept_all(600001);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::msgpack));
-    }
-
-    SECTION("a well-formed deep value is read into a value")
-    {
-        const std::size_t depth = 10000;
-        std::vector<uint8_t> input(depth, 0x91);
-        input.push_back(0x01);
-
-        json j = json::from_msgpack(input);
-
-        std::size_t measured = 0;
-        const json* p = &j;
-        while (p->is_array() && !p->empty())
-        {
-            p = &p->front();
-            ++measured;
-        }
-        CHECK(measured == depth);
-        CHECK(p->is_number());
-    }
-
-    SECTION("containers are still read the same way")
-    {
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0x90})) == json::array());
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0x80})) == json::object());
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0x92, 0x90, 0x80})) == json({json::array(), json::object()}));
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0x91, 0x91, 0x91, 0x90})) == json({{{json::array()}}}));
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0x81, 0xA1, 'a', 0x81, 0xA1, 'b', 0x92, 0x01, 0x02})) == json({{"a", {{"b", {1, 2}}}}}));
-        // array 16 and map 32, i.e. the counted forms
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0xDC, 0x00, 0x02, 0x01, 0x02})) == json({1, 2}));
-        CHECK(json::from_msgpack(std::vector<uint8_t>({0xDF, 0x00, 0x00, 0x00, 0x01, 0xA1, 'k', 0xC3})) == json({{"k", true}}));
-    }
-}
-
 TEST_CASE("single MessagePack roundtrip")
 {
     SECTION("sample.json")

tests/src/unit-no-macro-leak.cpp

@@ -0,0 +1,486 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+// This file makes sure that none of the internal JSON_HEDLEY_* macros (vendored
+// from https://nemequ.github.io/hedley/, see
+// include/nlohmann/thirdparty/hedley/hedley.hpp) leak into the including
+// translation unit. include/nlohmann/detail/macro_unscope.hpp is supposed to
+// #undef every JSON_HEDLEY_* macro (via hedley_undef.hpp) once json.hpp has
+// been fully processed. See https://github.com/nlohmann/json/issues/5408,
+// where JSON_HEDLEY_PRAGMA, JSON_HEDLEY_PREDICT_TRUE, JSON_HEDLEY_PREDICT_FALSE,
+// and JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE escaped this cleanup because
+// hedley_undef.hpp had no matching #undef for them.
+//
+// The #ifdef/#error checks below are mechanically derived from the full list
+// of macro names in hedley_undef.hpp, so every JSON_HEDLEY_* macro is covered
+// -- not just the four that leaked historically.
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+
+#ifdef JSON_HEDLEY_ALWAYS_INLINE
+    #error "JSON_HEDLEY_ALWAYS_INLINE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_ARM_VERSION
+    #error "JSON_HEDLEY_ARM_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_ARM_VERSION_CHECK
+    #error "JSON_HEDLEY_ARM_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_ARRAY_PARAM
+    #error "JSON_HEDLEY_ARRAY_PARAM must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_ASSUME
+    #error "JSON_HEDLEY_ASSUME must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_BEGIN_C_DECLS
+    #error "JSON_HEDLEY_BEGIN_C_DECLS must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+    #error "JSON_HEDLEY_CLANG_HAS_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_BUILTIN
+    #error "JSON_HEDLEY_CLANG_HAS_BUILTIN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+    #error "JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
+    #error "JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_EXTENSION
+    #error "JSON_HEDLEY_CLANG_HAS_EXTENSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_FEATURE
+    #error "JSON_HEDLEY_CLANG_HAS_FEATURE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CLANG_HAS_WARNING
+    #error "JSON_HEDLEY_CLANG_HAS_WARNING must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_COMPCERT_VERSION
+    #error "JSON_HEDLEY_COMPCERT_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+    #error "JSON_HEDLEY_COMPCERT_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONCAT
+    #error "JSON_HEDLEY_CONCAT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONCAT3
+    #error "JSON_HEDLEY_CONCAT3 must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONCAT3_EX
+    #error "JSON_HEDLEY_CONCAT3_EX must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONCAT_EX
+    #error "JSON_HEDLEY_CONCAT_EX must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONST
+    #error "JSON_HEDLEY_CONST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONSTEXPR
+    #error "JSON_HEDLEY_CONSTEXPR must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CONST_CAST
+    #error "JSON_HEDLEY_CONST_CAST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CPP_CAST
+    #error "JSON_HEDLEY_CPP_CAST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CRAY_VERSION
+    #error "JSON_HEDLEY_CRAY_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_CRAY_VERSION_CHECK
+    #error "JSON_HEDLEY_CRAY_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_C_DECL
+    #error "JSON_HEDLEY_C_DECL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DEPRECATED
+    #error "JSON_HEDLEY_DEPRECATED must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DEPRECATED_FOR
+    #error "JSON_HEDLEY_DEPRECATED_FOR must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+    #error "JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_POP
+    #error "JSON_HEDLEY_DIAGNOSTIC_POP must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #error "JSON_HEDLEY_DIAGNOSTIC_PUSH must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DMC_VERSION
+    #error "JSON_HEDLEY_DMC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_DMC_VERSION_CHECK
+    #error "JSON_HEDLEY_DMC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_EMPTY_BASES
+    #error "JSON_HEDLEY_EMPTY_BASES must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION
+    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+    #error "JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_END_C_DECLS
+    #error "JSON_HEDLEY_END_C_DECLS must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_FALL_THROUGH
+    #error "JSON_HEDLEY_FALL_THROUGH must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_FLAGS
+    #error "JSON_HEDLEY_FLAGS must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_FLAGS_CAST
+    #error "JSON_HEDLEY_FLAGS_CAST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+    #error "JSON_HEDLEY_GCC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_BUILTIN
+    #error "JSON_HEDLEY_GCC_HAS_BUILTIN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+    #error "JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+    #error "JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_EXTENSION
+    #error "JSON_HEDLEY_GCC_HAS_EXTENSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_FEATURE
+    #error "JSON_HEDLEY_GCC_HAS_FEATURE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_HAS_WARNING
+    #error "JSON_HEDLEY_GCC_HAS_WARNING must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+    #error "JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_VERSION
+    #error "JSON_HEDLEY_GCC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GCC_VERSION_CHECK
+    #error "JSON_HEDLEY_GCC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+    #error "JSON_HEDLEY_GNUC_HAS_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_BUILTIN
+    #error "JSON_HEDLEY_GNUC_HAS_BUILTIN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+    #error "JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+    #error "JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_EXTENSION
+    #error "JSON_HEDLEY_GNUC_HAS_EXTENSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_FEATURE
+    #error "JSON_HEDLEY_GNUC_HAS_FEATURE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_HAS_WARNING
+    #error "JSON_HEDLEY_GNUC_HAS_WARNING must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_VERSION
+    #error "JSON_HEDLEY_GNUC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_GNUC_VERSION_CHECK
+    #error "JSON_HEDLEY_GNUC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_ATTRIBUTE
+    #error "JSON_HEDLEY_HAS_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_BUILTIN
+    #error "JSON_HEDLEY_HAS_BUILTIN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+    #error "JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+    #error "JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_EXTENSION
+    #error "JSON_HEDLEY_HAS_EXTENSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_FEATURE
+    #error "JSON_HEDLEY_HAS_FEATURE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_HAS_WARNING
+    #error "JSON_HEDLEY_HAS_WARNING must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IAR_VERSION
+    #error "JSON_HEDLEY_IAR_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IAR_VERSION_CHECK
+    #error "JSON_HEDLEY_IAR_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IBM_VERSION
+    #error "JSON_HEDLEY_IBM_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IBM_VERSION_CHECK
+    #error "JSON_HEDLEY_IBM_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IMPORT
+    #error "JSON_HEDLEY_IMPORT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_INLINE
+    #error "JSON_HEDLEY_INLINE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_INTEL_CL_VERSION
+    #error "JSON_HEDLEY_INTEL_CL_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+    #error "JSON_HEDLEY_INTEL_CL_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_INTEL_VERSION
+    #error "JSON_HEDLEY_INTEL_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_INTEL_VERSION_CHECK
+    #error "JSON_HEDLEY_INTEL_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IS_CONSTANT
+    #error "JSON_HEDLEY_IS_CONSTANT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_IS_CONSTEXPR_
+    #error "JSON_HEDLEY_IS_CONSTEXPR_ must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_LIKELY
+    #error "JSON_HEDLEY_LIKELY must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MALLOC
+    #error "JSON_HEDLEY_MALLOC must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MCST_LCC_VERSION
+    #error "JSON_HEDLEY_MCST_LCC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+    #error "JSON_HEDLEY_MCST_LCC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MESSAGE
+    #error "JSON_HEDLEY_MESSAGE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MSVC_VERSION
+    #error "JSON_HEDLEY_MSVC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_MSVC_VERSION_CHECK
+    #error "JSON_HEDLEY_MSVC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NEVER_INLINE
+    #error "JSON_HEDLEY_NEVER_INLINE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NON_NULL
+    #error "JSON_HEDLEY_NON_NULL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NO_ESCAPE
+    #error "JSON_HEDLEY_NO_ESCAPE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NO_RETURN
+    #error "JSON_HEDLEY_NO_RETURN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NO_THROW
+    #error "JSON_HEDLEY_NO_THROW must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_NULL
+    #error "JSON_HEDLEY_NULL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PELLES_VERSION
+    #error "JSON_HEDLEY_PELLES_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PELLES_VERSION_CHECK
+    #error "JSON_HEDLEY_PELLES_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PGI_VERSION
+    #error "JSON_HEDLEY_PGI_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PGI_VERSION_CHECK
+    #error "JSON_HEDLEY_PGI_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PRAGMA
+    #error "JSON_HEDLEY_PRAGMA must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PREDICT
+    #error "JSON_HEDLEY_PREDICT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PREDICT_FALSE
+    #error "JSON_HEDLEY_PREDICT_FALSE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PREDICT_TRUE
+    #error "JSON_HEDLEY_PREDICT_TRUE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PRINTF_FORMAT
+    #error "JSON_HEDLEY_PRINTF_FORMAT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PRIVATE
+    #error "JSON_HEDLEY_PRIVATE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PUBLIC
+    #error "JSON_HEDLEY_PUBLIC must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_PURE
+    #error "JSON_HEDLEY_PURE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_REINTERPRET_CAST
+    #error "JSON_HEDLEY_REINTERPRET_CAST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_REQUIRE
+    #error "JSON_HEDLEY_REQUIRE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_REQUIRE_CONSTEXPR
+    #error "JSON_HEDLEY_REQUIRE_CONSTEXPR must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_REQUIRE_MSG
+    #error "JSON_HEDLEY_REQUIRE_MSG must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_RESTRICT
+    #error "JSON_HEDLEY_RESTRICT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_RETURNS_NON_NULL
+    #error "JSON_HEDLEY_RETURNS_NON_NULL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_SENTINEL
+    #error "JSON_HEDLEY_SENTINEL must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_STATIC_ASSERT
+    #error "JSON_HEDLEY_STATIC_ASSERT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_STATIC_CAST
+    #error "JSON_HEDLEY_STATIC_CAST must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_STRINGIFY
+    #error "JSON_HEDLEY_STRINGIFY must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_STRINGIFY_EX
+    #error "JSON_HEDLEY_STRINGIFY_EX must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_SUNPRO_VERSION
+    #error "JSON_HEDLEY_SUNPRO_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+    #error "JSON_HEDLEY_SUNPRO_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TINYC_VERSION
+    #error "JSON_HEDLEY_TINYC_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TINYC_VERSION_CHECK
+    #error "JSON_HEDLEY_TINYC_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_ARMCL_VERSION
+    #error "JSON_HEDLEY_TI_ARMCL_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_ARMCL_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL2000_VERSION
+    #error "JSON_HEDLEY_TI_CL2000_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_CL2000_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL430_VERSION
+    #error "JSON_HEDLEY_TI_CL430_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_CL430_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL6X_VERSION
+    #error "JSON_HEDLEY_TI_CL6X_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_CL6X_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL7X_VERSION
+    #error "JSON_HEDLEY_TI_CL7X_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_CL7X_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CLPRU_VERSION
+    #error "JSON_HEDLEY_TI_CLPRU_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_CLPRU_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_VERSION
+    #error "JSON_HEDLEY_TI_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_TI_VERSION_CHECK
+    #error "JSON_HEDLEY_TI_VERSION_CHECK must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_UNAVAILABLE
+    #error "JSON_HEDLEY_UNAVAILABLE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_UNLIKELY
+    #error "JSON_HEDLEY_UNLIKELY must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_UNPREDICTABLE
+    #error "JSON_HEDLEY_UNPREDICTABLE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_UNREACHABLE
+    #error "JSON_HEDLEY_UNREACHABLE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_UNREACHABLE_RETURN
+    #error "JSON_HEDLEY_UNREACHABLE_RETURN must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_VERSION
+    #error "JSON_HEDLEY_VERSION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_VERSION_DECODE_MAJOR
+    #error "JSON_HEDLEY_VERSION_DECODE_MAJOR must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_VERSION_DECODE_MINOR
+    #error "JSON_HEDLEY_VERSION_DECODE_MINOR must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_VERSION_DECODE_REVISION
+    #error "JSON_HEDLEY_VERSION_DECODE_REVISION must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_VERSION_ENCODE
+    #error "JSON_HEDLEY_VERSION_ENCODE must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_WARNING
+    #error "JSON_HEDLEY_WARNING must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT
+    #error "JSON_HEDLEY_WARN_UNUSED_RESULT must not remain defined after including json.hpp"
+#endif
+#ifdef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+    #error "JSON_HEDLEY_WARN_UNUSED_RESULT_MSG must not remain defined after including json.hpp"
+#endif
+
+TEST_CASE("no JSON_HEDLEY_* macro leaks after including json.hpp")
+{
+    // if this test compiles at all, none of the JSON_HEDLEY_* macros checked
+    // above remained defined after including <nlohmann/json.hpp>
+    CHECK(true);
+}

tests/src/unit-ubjson.cpp

@@ -2149,172 +2149,6 @@ TEST_CASE("UBJSON")
     }
 }
 
-TEST_CASE("UBJSON nesting does not consume the call stack")
-{
-    // Containers used to be read by calling back into the value reader once
-    // per element, so the native call stack grew with the nesting depth of the
-    // input. '[' alone opens a container, so a payload of repeated '[' crashed
-    // the process (#5104), as did the optimized forms, which reach the same
-    // path through a type or size annotation. The containers are kept on a
-    // heap stack now.
-    //
-    // Deeply nested values must not be compared, copied or dumped here: those
-    // operations are still recursive and would reintroduce the crash.
-    json _;
-
-    SECTION("containers that end at a marker")
-    {
-        const std::vector<uint8_t> input(500000, '[');
-        CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.parse_error.110] parse error at byte 500001: syntax error while parsing UBJSON value: unexpected end of input", json::parse_error&);
-        CHECK(json::from_ubjson(input, true, false).is_discarded());
-    }
-
-    SECTION("containers with a size")
-    {
-        std::vector<uint8_t> input;
-        for (std::size_t i = 0; i < 100000; ++i)
-        {
-            input.push_back('[');
-            input.push_back('#');
-            input.push_back('i');
-            input.push_back(1);
-        }
-        CHECK_THROWS_AS(_ = json::from_ubjson(input), json::parse_error&);
-        CHECK(json::from_ubjson(input, true, false).is_discarded());
-    }
-
-    SECTION("containers with a type and a size")
-    {
-        // '[' is a permitted optimized type in UBJSON, so each element of such
-        // a container is itself a container, read without a marker of its own
-        std::vector<uint8_t> input;
-        for (std::size_t i = 0; i < 100000; ++i)
-        {
-            const std::vector<uint8_t> level = {'[', '$', '[', '#', 'i', 1};
-            input.insert(input.end(), level.begin(), level.end());
-        }
-        CHECK_THROWS_AS(_ = json::from_ubjson(input), json::parse_error&);
-        CHECK(json::from_ubjson(input, true, false).is_discarded());
-    }
-
-    SECTION("a well-formed deep value is read through the SAX interface")
-    {
-        std::vector<uint8_t> input(100000, '[');
-        input.insert(input.end(), 100000, ']');
-
-        SaxCountdown accept_all(1000000);
-        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::ubjson));
-    }
-
-    SECTION("a well-formed deep value is read into a value")
-    {
-        const std::size_t depth = 10000;
-        std::vector<uint8_t> input(depth, '[');
-        input.insert(input.end(), depth, ']');
-
-        json j = json::from_ubjson(input);
-
-        std::size_t measured = 0;
-        const json* p = &j;
-        while (p->is_array() && !p->empty())
-        {
-            p = &p->front();
-            ++measured;
-        }
-        // the innermost array is empty, so the descent stops one level short
-        CHECK(measured == depth - 1);
-    }
-
-    SECTION("containers are still read the same way")
-    {
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', ']'})) == json::array());
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'{', '}'})) == json::object());
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '#', 'i', 0})) == json::array());
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'{', '#', 'i', 0})) == json::object());
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'i', '#', 'i', 2, 1, 2})) == json({1, 2}));
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '#', 'i', 2, 'i', 1, 'i', 2})) == json({1, 2}));
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'{', '$', 'i', '#', 'i', 1, 'i', 1, 'a', 1})) == json({{"a", 1}}));
-        // a no-op is not a value, so a container of them holds none
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'N', '#', 'i', 2})) == json::array());
-        // sized and unsized forms nested inside one another
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '[', '#', 'i', 2, 'i', 1, 'i', 2, ']'})) == json({{1, 2}}));
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '#', 'i', 1, '[', 'i', 1, ']'})) == json({{1}}));
-        // an optimized container of containers
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', '[', '#', 'i', 2, 'i', 1, ']', 'i', 2, ']'})) == json({{1}, {2}}));
-    }
-
-    SECTION("BJData containers are still read the same way")
-    {
-        // the ND-array wrapper and the binary shortcut are complete values,
-        // not containers the reader descends into
-        CHECK(json::from_bjdata(std::vector<uint8_t>({'[', '$', 'U', '#', '[', '$', 'i', '#', 'i', 2, 2, 3, 1, 2, 3, 4, 5, 6})) ==
-        json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}}));
-        CHECK(json::from_bjdata(std::vector<uint8_t>({'[', '$', 'i', '#', 'i', 2, 1, 2})) == json({1, 2}));
-        CHECK(json::from_bjdata(std::vector<uint8_t>({'[', '[', 'i', 1, ']', ']'})) == json({{1}}));
-    }
-}
-
-TEST_CASE("UBJSON optimized arrays of a valueless type are bounded")
-{
-    // An element of type 'Z', 'T' or 'F' is encoded by its marker alone, so an
-    // optimized array of one of those has no payload and the declared count is
-    // the only thing deciding how much is allocated. Ten bytes used to produce
-    // billions of values (#2793); every other type costs at least one byte per
-    // element and is bounded by the end of the input.
-    json _;
-
-    SECTION("an excessive count is rejected")
-    {
-        // 'l' is a big-endian int32: 0x7FFFFFFF elements, about 34 GB of value
-        for (const auto marker :
-                {'Z', 'T', 'F'
-                })
-        {
-            const std::vector<uint8_t> input = {'[', '$', static_cast<uint8_t>(marker), '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF};
-            CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size", json::out_of_range&);
-            CHECK(json::from_ubjson(input, true, false).is_discarded());
-        }
-    }
-
-    SECTION("ordinary counts are unaffected")
-    {
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'Z', '#', 'i', 3})) == json({nullptr, nullptr, nullptr}));
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'T', '#', 'i', 2})) == json({true, true}));
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'F', '#', 'i', 2})) == json({false, false}));
-        // 'N' is a no-op rather than a value, and still yields an empty array
-        CHECK(json::from_ubjson(std::vector<uint8_t>({'[', '$', 'N', '#', 'i', 2})) == json::array());
-    }
-
-    SECTION("a type with a payload is unaffected")
-    {
-        // A count past the limit is not rejected for 'U', which costs a byte
-        // per element and is bounded by the end of the input instead. The
-        // count is kept just past the limit rather than made huge, because a
-        // count that also exceeds the array's max_size() is reported as
-        // out_of_range before the input runs out, and max_size() depends on
-        // the width of std::size_t.
-        const std::vector<uint8_t> input = {'[', '$', 'U', '#', 'l', 0x00, 0x10, 0x00, 0x01};
-        CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.parse_error.110] parse error at byte 10: syntax error while parsing UBJSON number: unexpected end of input", json::parse_error&);
-        CHECK(json::from_ubjson(input, true, false).is_discarded());
-    }
-
-    SECTION("the writer stays within what the reader accepts")
-    {
-        // below the limit the optimized form is used and is tiny; above it the
-        // writer falls back so that the result can still be read back
-        json const at_limit(1048576, nullptr);
-        const auto v_at_limit = json::to_ubjson(at_limit, true, true);
-        CHECK(v_at_limit.size() == 9);
-        CHECK(v_at_limit.at(1) == '$');
-        CHECK(json::from_ubjson(v_at_limit) == at_limit);
-
-        json const above_limit(1048577, nullptr);
-        const auto v_above_limit = json::to_ubjson(above_limit, true, true);
-        CHECK(v_above_limit.at(1) != '$');
-        CHECK(json::from_ubjson(v_above_limit) == above_limit);
-    }
-}
-
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
     SECTION("Null Value")