Make scalar comparisons noexcept only when converting the scalar cannot throw

[nlohmann]

Stacked on #5750.

Problem

The comparison operators that take a scalar (==, !=, <, <=, >, >=, and C++20's <=>) convert the scalar with basic_json(scalar) and then compare two JSON values. They were all unconditionally noexcept, so a conversion that throws called std::terminate instead of propagating the exception:

enum class card { kreuz, andere };
NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(card, {{card::kreuz, "kreuz"}})

json j = "kreuz";
bool b = (card::andere == j);  // to_json throws out_of_range.410 -> std::terminate()

The same happens with j == "text" if allocating the string throws std::bad_alloc. clang-tidy 22.1 reports the strict-enum case as bugprone-exception-escape; #5750 worked around it by rewriting the tests.

Change

• The fix: the 16 scalar overloads are now noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value), so each one is noexcept exactly when the conversion is:
  • numbers, Booleans, nullptr, and plain enums: still noexcept
  • strings and enums whose to_json may throw (NLOHMANN_JSON_SERIALIZE_ENUM / _STRICT): now noexcept(false)
• Unchanged: comparing two basic_json values.
• Tests:
  • restore the strict-enum comparisons that Fix CI on develop #5750 removed
  • check that comparing an unmapped strict enum throws out_of_range.410 (it used to terminate)
  • pin the new exception specifications with static_asserts in unit-noexcept.cpp
• Docs: all seven operator pages now state overload (2)'s exception safety and list the change in their version history (3.13.0).

Verification

• Local test runs, all passing:
  • unit-conversions and unit-noexcept, as C++11 and C++20, with clang 21 and GCC 16
  • unit-comparison, as C++11, C++20, and C++20 with JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
• clang-tidy 22.1.8 (CI's setup) is clean on both test files in the standards CI builds them in.
• make check-amalgamation: passes.

Public API

This changes the documented exception specification of the scalar comparison operators, but no program that compiles today stops compiling:

• Comparisons with numbers, Booleans, nullptr, and plain enums stay noexcept.
• Comparisons with strings and with enums serialized by the enum macros become noexcept(false). In those cases the operator could already fail; it now throws instead of calling std::terminate.
• Code that checks noexcept(j == "text") at compile time will see false.

The ABI is unaffected: a function's exception specification is not part of its mangled name.

🤖 Generated with Claude Code