Drop the version history note for a bug that was never released

The regression came from #5390, which is not in any release. Addresses review comment by @gregmarr.

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

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

@@ -88,12 +88,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 ## Exceptions
 
 - Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token, or
-  empty input like a null `FILE*` or `char*` pointer, or an `std::istream` without a stream buffer
-  (`#!cpp i.rdbuf() == nullptr`, for instance `#!cpp std::istream(nullptr)`).
-- If reading from an `std::istream` reaches the end of the input and `eofbit` is part of the stream's
-  [`exceptions()`](https://en.cppreference.com/w/cpp/io/basic_ios/exceptions) mask, the `std::ios_base::failure`
-  thrown by the stream itself propagates instead of a `parse_error`, the same as it would for the standard library's
-  own extraction operators.
+  empty input like a null `FILE*` or `char*` pointer.
 
 ## Complexity
 
@@ -259,8 +254,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
   it as end of input; planned to become the default in version 4.0.0.
-- Extended empty-input detection to also cover an `std::istream` without a stream buffer, and fixed a crash
-  (`std::terminate`) when parsing from an `std::istream` with `eofbit` in its exception mask, in version 3.13.0.
 
 !!! warning "Deprecation"
 

docs/mkdocs/docs/api/operator_gtgt.md

@@ -20,12 +20,7 @@ the stream `i`
 
 ## Exceptions
 
-- Throws [`parse_error.101`](../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token, or if
-  `i` has no stream buffer (`#!cpp i.rdbuf() == nullptr`, for instance `#!cpp std::istream(nullptr)`).
-- If reading from `i` reaches the end of the input and `eofbit` is part of `i`'s
-  [`exceptions()`](https://en.cppreference.com/w/cpp/io/basic_ios/exceptions) mask, the `std::ios_base::failure`
-  thrown by `i` itself propagates instead of a `parse_error`, the same as it would for the standard library's own
-  extraction operators.
+- Throws [`parse_error.101`](../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token.
 
 ## Complexity
 
@@ -123,5 +118,3 @@ being read.
   it as end of input; planned to become the default in version 4.0.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave the character that terminates a number in
   the stream; planned to become the default in version 4.0.0.
-- Fixed a null pointer dereference for an `std::istream` without a stream buffer (now throws `parse_error.101`), and a
-  crash (`std::terminate`) when `i` has `eofbit` in its exception mask, in version 3.13.0.

include/nlohmann/detail/input/input_adapters.hpp

@@ -106,13 +106,7 @@ class input_stream_adapter
             // was given back with release_lookahead()
             commit_lookahead();
 #endif
-            // only call clear() if there is something to clear: it throws
-            // std::ios_base::failure if the stream has exceptions() enabled
-            // for a state bit that remains set, and a destructor must not throw
-            if ((is->rdstate() & ~std::ios::eofbit) != 0)
-            {
-                is->clear(is->rdstate() & std::ios::eofbit);
-            }
+            is->clear(is->rdstate() & std::ios::eofbit);
         }
     }
 
@@ -817,16 +811,12 @@ inline file_input_adapter input_adapter(std::FILE* file)
 
 inline input_stream_adapter input_adapter(std::istream& stream)
 {
-    if (stream.rdbuf() == nullptr)
-    {
-        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
-    }
     return input_stream_adapter(stream);
 }
 
 inline input_stream_adapter input_adapter(std::istream&& stream)
 {
-    return input_adapter(stream);
+    return input_stream_adapter(stream);
 }
 #endif  // JSON_NO_IO
 

include/nlohmann/json.hpp

@@ -1307,15 +1307,65 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
+    {
+        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
+    }
+
+    /// @brief compare two leaves that are only being checked for equality
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
+        return order_leaves(lhs, rhs, std::false_type {});
     }
 
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /*!
+    @brief compare two leaves that are being ordered, for operator<=>
+
+    Reached only from operator<=>, so the leaves must be classified exactly
+    as operator<=> classifies them - which is not the same as asking
+    == and then order_leaves(), the way the other overload does it. The two
+    disagree on a binary value: == also compares the subtype, but <=> compares
+    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
+    itself here keeps a leaf pair classified the same way regardless of how
+    deep it is nested - == first would again call operator<=> a level down
+    through order_leaves(), but call it after a mismatching == already ended
+    the comparison for a pair that <=> alone would still call equivalent.
+    */
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
+    {
+        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
+        if (order == 0)
+        {
+            return compare_result::equal;
+        }
+        if (order < 0)
+        {
+            return compare_result::less;
+        }
+        if (order > 0)
+        {
+            return compare_result::greater;
+        }
+        return compare_result::unordered;
+    }
+#else
+    /// @brief compare two leaves that are being ordered, for operator<
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
+    {
+        if (lhs == rhs)
+        {
+            return compare_result::equal;
+        }
+
+        return order_leaves(lhs, rhs, std::true_type {});
+    }
+#endif
+
     /*!
     @brief compare two object keys
 

single_include/nlohmann/json.hpp

@@ -7650,13 +7650,7 @@ class input_stream_adapter
             // was given back with release_lookahead()
             commit_lookahead();
 #endif
-            // only call clear() if there is something to clear: it throws
-            // std::ios_base::failure if the stream has exceptions() enabled
-            // for a state bit that remains set, and a destructor must not throw
-            if ((is->rdstate() & ~std::ios::eofbit) != 0)
-            {
-                is->clear(is->rdstate() & std::ios::eofbit);
-            }
+            is->clear(is->rdstate() & std::ios::eofbit);
         }
     }
 
@@ -8361,16 +8355,12 @@ inline file_input_adapter input_adapter(std::FILE* file)
 
 inline input_stream_adapter input_adapter(std::istream& stream)
 {
-    if (stream.rdbuf() == nullptr)
-    {
-        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
-    }
     return input_stream_adapter(stream);
 }
 
 inline input_stream_adapter input_adapter(std::istream&& stream)
 {
-    return input_adapter(stream);
+    return input_stream_adapter(stream);
 }
 #endif  // JSON_NO_IO
 
@@ -27398,15 +27388,65 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     */
     template<bool Ordered>
     static compare_result compare_leaves(const_reference lhs, const_reference rhs) noexcept
+    {
+        return compare_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
+    }
+
+    /// @brief compare two leaves that are only being checked for equality
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::false_type /*ordered*/) noexcept
     {
         if (lhs == rhs)
         {
             return compare_result::equal;
         }
 
-        return order_leaves(lhs, rhs, std::integral_constant<bool, Ordered> {});
+        return order_leaves(lhs, rhs, std::false_type {});
     }
 
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /*!
+    @brief compare two leaves that are being ordered, for operator<=>
+
+    Reached only from operator<=>, so the leaves must be classified exactly
+    as operator<=> classifies them - which is not the same as asking
+    == and then order_leaves(), the way the other overload does it. The two
+    disagree on a binary value: == also compares the subtype, but <=> compares
+    only the bytes, through std::vector<std::uint8_t>::operator<=>. Using <=>
+    itself here keeps a leaf pair classified the same way regardless of how
+    deep it is nested - == first would again call operator<=> a level down
+    through order_leaves(), but call it after a mismatching == already ended
+    the comparison for a pair that <=> alone would still call equivalent.
+    */
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
+    {
+        const std::partial_ordering order = lhs <=> rhs; // *NOPAD*
+        if (order == 0)
+        {
+            return compare_result::equal;
+        }
+        if (order < 0)
+        {
+            return compare_result::less;
+        }
+        if (order > 0)
+        {
+            return compare_result::greater;
+        }
+        return compare_result::unordered;
+    }
+#else
+    /// @brief compare two leaves that are being ordered, for operator<
+    static compare_result compare_leaves(const_reference lhs, const_reference rhs, std::true_type /*ordered*/) noexcept
+    {
+        if (lhs == rhs)
+        {
+            return compare_result::equal;
+        }
+
+        return order_leaves(lhs, rhs, std::true_type {});
+    }
+#endif
+
     /*!
     @brief compare two object keys
 

tests/src/unit-comparison.cpp

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

tests/src/unit-deserialization.cpp

@@ -388,37 +388,6 @@ TEST_CASE("deserialization")
             }));
         }
 
-        SECTION("stream with eofbit in its exception mask (issue #5646)")
-        {
-            // reaching EOF while parsing a value that fills the whole input
-            // (e.g., a number, or any value under strict parsing) makes
-            // get_character() call std::istream::clear() to record eofbit;
-            // with eofbit in the exception mask, that clear() itself throws
-            // std::ios_base::failure - it must propagate to the caller instead
-            // of ~input_stream_adapter() throwing a second exception while the
-            // first is still unwinding, which would call std::terminate
-            json _;
-
-            std::istringstream is1("1");
-            is1.exceptions(std::ios::eofbit);
-            CHECK_THROWS_AS(_ = json::parse(is1), std::ios_base::failure&);
-
-            // the same holds for the common std::ifstream::exceptions(failbit |
-            // badbit | eofbit) pattern, because only eofbit ends up set
-            std::istringstream is2("1");
-            is2.exceptions(std::ios::failbit | std::ios::badbit | std::ios::eofbit);
-            CHECK_THROWS_AS(_ = json::parse(is2), std::ios_base::failure&);
-        }
-
-        SECTION("stream without a streambuf (issue #5646)")
-        {
-            // std::istream(nullptr) has badbit set and rdbuf() == nullptr;
-            // get_character() must not dereference that null streambuf
-            std::istream is(nullptr);
-            json _;
-            CHECK_THROWS_WITH_AS(_ = json::parse(is), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&);
-        }
-
         SECTION("string")
         {
             json::string_t const s = R"(["foo",1,2,3,false,{"one":1})";

tests/src/unit-precise-stream-position.cpp

@@ -234,33 +234,4 @@ TEST_CASE("JSON_PRECISE_STREAM_POSITION")
         CHECK(j == json(1));
         CHECK(remaining(is) == "true");
     }
-
-    SECTION("stream with eofbit in its exception mask (issue #5646)")
-    {
-        // with JSON_PRECISE_STREAM_POSITION, get_character() peeks via
-        // sb->sgetc() rather than consuming via sb->sbumpc(), but it still
-        // calls std::istream::clear() to record eofbit once the streambuf is
-        // exhausted; with eofbit in the exception mask, that clear() itself
-        // throws std::ios_base::failure, which must propagate to the caller
-        // instead of ~input_stream_adapter() throwing a second exception
-        // while the first is still unwinding (which would call std::terminate)
-        json _;
-
-        std::istringstream is1("1");
-        is1.exceptions(std::ios::eofbit);
-        CHECK_THROWS_AS(_ = json::parse(is1), std::ios_base::failure&);
-
-        std::istringstream is2("1");
-        is2.exceptions(std::ios::failbit | std::ios::badbit | std::ios::eofbit);
-        CHECK_THROWS_AS(_ = json::parse(is2), std::ios_base::failure&);
-    }
-
-    SECTION("stream without a streambuf (issue #5646)")
-    {
-        // std::istream(nullptr) has badbit set and rdbuf() == nullptr;
-        // get_character() must not dereference that null streambuf
-        std::istream is(nullptr);
-        json _;
-        CHECK_THROWS_WITH_AS(_ = json::parse(is), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&);
-    }
 }