Broaden JSON_HEDLEY_WARN_UNUSED_RESULT coverage to pure query functions

Add JSON_HEDLEY_WARN_UNUSED_RESULT to the unambiguous, const,
side-effect-free observer functions whose return value is the entire
purpose of the call:

- dump()
- type(), type_name()
- all is_* predicates (is_primitive, is_structured, is_null,
  is_boolean, is_number, is_number_integer, is_number_unsigned,
  is_number_float, is_object, is_array, is_string, is_binary,
  is_discarded)
- empty(), size(), max_size()
- count(...) (both overloads) and contains(...) (all overloads,
  including the deprecated json_pointer<BasicJsonType> overload)

This mirrors the direction the standard library has taken with
[[nodiscard]] on the analogous std::vector/std::map members, and
catches real bugs such as `j.empty();` (meant `j.clear();`) or
`j.contains(k);` with the result thrown away.

Deliberately out of scope (left for a separate, later policy
decision, per the issue): at(), value(), get*(), flatten(),
unflatten(), patch(), merge_patch(), begin()/end(), comparison
operators, erase(), and emplace().

Compiling the full test suite (tests/src/unit-*.cpp) with
-Wunused-result -Werror uncovered one real hit: a regression test in
unit-regression2.cpp called dump() purely to check it does not throw,
discarding the result. Fixed by explicitly casting to void, since the
call is intentionally result-less there.

Fixes #5410

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 -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
+	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
 	$(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

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__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
     if (value == 0) // +-0
     {
@@ -1086,7 +1086,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '0';
         return first;
     }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#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__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -286,4 +286,6 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif

include/nlohmann/detail/iterators/iteration_proxy.hpp

@@ -18,7 +18,6 @@
 #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>
@@ -207,10 +206,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 
-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #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)
@@ -224,7 +223,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                      get<N>(std::declval <
                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 }  // namespace std
 

include/nlohmann/detail/output/binary_writer.hpp

@@ -1849,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__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#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)()) &&
@@ -1869,7 +1869,9 @@ class binary_writer
                                 : get_msgpack_float_prefix(n));
             write_number(n);
         }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
   public:

include/nlohmann/json.hpp

@@ -1335,6 +1335,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief serialization
     /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     string_t dump(const int indent = -1,
                   const char indent_char = ' ',
                   const bool ensure_ascii = false,
@@ -1357,6 +1358,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type of the JSON value (explicit)
     /// @sa https://json.nlohmann.me/api/basic_json/type/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr value_t type() const noexcept
     {
         return m_data.m_type;
@@ -1364,6 +1366,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is primitive
     /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_primitive() const noexcept
     {
         return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -1371,6 +1374,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is structured
     /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_structured() const noexcept
     {
         return is_array() || is_object();
@@ -1378,6 +1382,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is null
     /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_null() const noexcept
     {
         return m_data.m_type == value_t::null;
@@ -1385,6 +1390,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a boolean
     /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_boolean() const noexcept
     {
         return m_data.m_type == value_t::boolean;
@@ -1392,6 +1398,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number() const noexcept
     {
         return is_number_integer() || is_number_float();
@@ -1399,6 +1406,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_integer() const noexcept
     {
         return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -1406,6 +1414,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an unsigned integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_unsigned() const noexcept
     {
         return m_data.m_type == value_t::number_unsigned;
@@ -1413,6 +1422,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a floating-point number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_float() const noexcept
     {
         return m_data.m_type == value_t::number_float;
@@ -1420,6 +1430,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an object
     /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_object() const noexcept
     {
         return m_data.m_type == value_t::object;
@@ -1427,6 +1438,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an array
     /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_array() const noexcept
     {
         return m_data.m_type == value_t::array;
@@ -1434,6 +1446,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a string
     /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_string() const noexcept
     {
         return m_data.m_type == value_t::string;
@@ -1441,6 +1454,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a binary array
     /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_binary() const noexcept
     {
         return m_data.m_type == value_t::binary;
@@ -1448,6 +1462,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is discarded
     /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_discarded() const noexcept
     {
         return m_data.m_type == value_t::discarded;
@@ -2779,6 +2794,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of occurrences of a key in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/count/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(const typename object_t::key_type& key) const
     {
         // return 0 for all nonobject types
@@ -2789,6 +2805,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/count/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(KeyType && key) const
     {
         // return 0 for all nonobject types
@@ -2797,6 +2814,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const typename object_t::key_type& key) const
     {
         return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -2806,6 +2824,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(KeyType && key) const
     {
         return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -2813,12 +2832,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object given a JSON pointer
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const json_pointer& ptr) const
     {
         return ptr.contains(this);
     }
 
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
     {
@@ -2974,6 +2995,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief checks whether the container is empty.
     /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool empty() const noexcept
     {
         switch (m_data.m_type)
@@ -3013,6 +3035,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type size() const noexcept
     {
         switch (m_data.m_type)
@@ -3052,6 +3075,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the maximum possible number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type max_size() const noexcept
     {
         switch (m_data.m_type)
@@ -3769,13 +3793,15 @@ 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__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         const_reference lhs = *this;
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -3860,12 +3886,14 @@ 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__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -4125,6 +4153,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief check if the input is valid JSON
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(InputType&& i,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -4136,6 +4165,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename IteratorType, typename SentinelType = IteratorType,
              detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(IteratorType first, SentinelType last,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -4235,6 +4265,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type as string
     /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_RETURNS_NON_NULL
     const char* type_name() const noexcept
     {

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_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -108,10 +108,7 @@
 #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

single_include/nlohmann/json.hpp

@@ -4944,9 +4944,9 @@ NLOHMANN_JSON_NAMESPACE_END
 // 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__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wweak-vtables")
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -5198,7 +5198,9 @@ class other_error : public exception
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 // #include <nlohmann/detail/macro_scope.hpp>
 
@@ -5973,8 +5975,6 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #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>
@@ -6204,10 +6204,10 @@ NLOHMANN_JSON_NAMESPACE_END
 namespace std
 {
 
-// Fix: https://github.com/nlohmann/json/issues/1401
-JSON_HEDLEY_DIAGNOSTIC_PUSH
 #if defined(__clang__)
-    JSON_HEDLEY_PRAGMA(clang diagnostic ignored "-Wmismatched-tags")
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #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)
@@ -6221,7 +6221,9 @@ class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
                      get<N>(std::declval <
                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
 };
-JSON_HEDLEY_DIAGNOSTIC_POP
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
 
 }  // namespace std
 
@@ -18855,9 +18857,9 @@ class binary_writer
 
     void write_compact_float(const number_float_t n, detail::input_format_t format)
     {
-        JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#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)()) &&
@@ -18875,7 +18877,9 @@ class binary_writer
                                 : get_msgpack_float_prefix(n));
             write_number(n);
         }
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
   public:
@@ -20048,9 +20052,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '-';
     }
 
-    JSON_HEDLEY_DIAGNOSTIC_PUSH
 #ifdef __GNUC__
-    JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
     if (value == 0) // +-0
     {
@@ -20060,7 +20064,9 @@ char* to_chars(char* first, const char* last, FloatType value)
         *first++ = '0';
         return first;
     }
-    JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 
     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
 
@@ -22757,6 +22763,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief serialization
     /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     string_t dump(const int indent = -1,
                   const char indent_char = ' ',
                   const bool ensure_ascii = false,
@@ -22779,6 +22786,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type of the JSON value (explicit)
     /// @sa https://json.nlohmann.me/api/basic_json/type/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr value_t type() const noexcept
     {
         return m_data.m_type;
@@ -22786,6 +22794,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is primitive
     /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_primitive() const noexcept
     {
         return is_null() || is_string() || is_boolean() || is_number() || is_binary();
@@ -22793,6 +22802,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether type is structured
     /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_structured() const noexcept
     {
         return is_array() || is_object();
@@ -22800,6 +22810,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is null
     /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_null() const noexcept
     {
         return m_data.m_type == value_t::null;
@@ -22807,6 +22818,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a boolean
     /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_boolean() const noexcept
     {
         return m_data.m_type == value_t::boolean;
@@ -22814,6 +22826,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number() const noexcept
     {
         return is_number_integer() || is_number_float();
@@ -22821,6 +22834,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_integer() const noexcept
     {
         return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
@@ -22828,6 +22842,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an unsigned integer number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_unsigned() const noexcept
     {
         return m_data.m_type == value_t::number_unsigned;
@@ -22835,6 +22850,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a floating-point number
     /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_number_float() const noexcept
     {
         return m_data.m_type == value_t::number_float;
@@ -22842,6 +22858,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an object
     /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_object() const noexcept
     {
         return m_data.m_type == value_t::object;
@@ -22849,6 +22866,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is an array
     /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_array() const noexcept
     {
         return m_data.m_type == value_t::array;
@@ -22856,6 +22874,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a string
     /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_string() const noexcept
     {
         return m_data.m_type == value_t::string;
@@ -22863,6 +22882,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is a binary array
     /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_binary() const noexcept
     {
         return m_data.m_type == value_t::binary;
@@ -22870,6 +22890,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return whether value is discarded
     /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     constexpr bool is_discarded() const noexcept
     {
         return m_data.m_type == value_t::discarded;
@@ -24201,6 +24222,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of occurrences of a key in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/count/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(const typename object_t::key_type& key) const
     {
         // return 0 for all nonobject types
@@ -24211,6 +24233,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/count/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type count(KeyType && key) const
     {
         // return 0 for all nonobject types
@@ -24219,6 +24242,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const typename object_t::key_type& key) const
     {
         return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
@@ -24228,6 +24252,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
     template<class KeyType, detail::enable_if_t<
                  detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(KeyType && key) const
     {
         return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
@@ -24235,12 +24260,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief check the existence of an element in a JSON object given a JSON pointer
     /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool contains(const json_pointer& ptr) const
     {
         return ptr.contains(this);
     }
 
     template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
     bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
     {
@@ -24396,6 +24423,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief checks whether the container is empty.
     /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     bool empty() const noexcept
     {
         switch (m_data.m_type)
@@ -24435,6 +24463,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type size() const noexcept
     {
         switch (m_data.m_type)
@@ -24474,6 +24503,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief returns the maximum possible number of elements
     /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     size_type max_size() const noexcept
     {
         switch (m_data.m_type)
@@ -25191,13 +25221,15 @@ 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__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         const_reference lhs = *this;
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -25282,12 +25314,14 @@ 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__
-        JSON_HEDLEY_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
         JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
-        JSON_HEDLEY_DIAGNOSTIC_POP
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
     }
 
     /// @brief comparison: equal
@@ -25547,6 +25581,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief check if the input is valid JSON
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(InputType&& i,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -25558,6 +25593,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @sa https://json.nlohmann.me/api/basic_json/accept/
     template<typename IteratorType, typename SentinelType = IteratorType,
              detail::enable_if_t<detail::can_compare_ne<IteratorType, SentinelType>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     static bool accept(IteratorType first, SentinelType last,
                        const bool ignore_comments = false,
                        const bool ignore_trailing_commas = false)
@@ -25657,6 +25693,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 
     /// @brief return the type as string
     /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
     JSON_HEDLEY_RETURNS_NON_NULL
     const char* type_name() const noexcept
     {
@@ -26955,7 +26992,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #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_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
 #undef JSON_HEDLEY_CLANG_HAS_WARNING
@@ -27046,10 +27083,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #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-no-macro-leak.cpp

@@ -1,486 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  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-regression2.cpp

@@ -639,7 +639,8 @@ TEST_CASE("regression tests 2")
                 s += static_cast<char>(i);
             }
             dump_test["1"] = s;
-            dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
+            // dump() is nodiscard; this only checks that dumping does not throw/crash
+            (void)dump_test.dump(-1, ' ', true, nlohmann::json::error_handler_t::replace);
         }
     }