Fix CI failures on develop from the API performance stack

- Mark the parameters of the new out-of-line throw helpers in json.hpp as
  used, as JSON_THROW drops its argument with JSON_NOEXCEPTION (clang
  -Wunused-parameter).
- all_children_leaves() iterates with begin()/end() via std::all_of: a
  custom array_t such as the one in the custom_array_type example has no
  rbegin() (examples check, clang-tidy readability-use-anyofallof).
- The rvalue to_json overloads (#5837) copy the elements of containers
  with const elements such as std::set instead of moving them: GCC 4.9's
  std::move_iterator cannot bind them. Object types are ruled out before
  std::ranges::view is checked, which needs an incomplete ordered_json
  for its object_t (GCC 11, C++20, unit-regression3 #3312).
- NOLINT the rvalue to_json parameters that are deliberately not
  forwarded, and fix the other clang-tidy findings (modernize-use-auto in
  zmij.hpp, readability-math-missing-parentheses in json_pointer.hpp).
- cpplint: NOLINT(readability/braces) on the new scalar fast-path macro
  like on JSON_IMPLEMENT_OPERATOR, and include <map> in json.hpp.
- Tests: drop a useless cast (GCC -Wuseless-cast) and a signed/unsigned
  comparison (MSVC C4018), wrap a vector<json> comparison in parentheses
  so doctest does not try to print it (ambiguous operator<< on MSVC), and
  also strip JSON_DIAGNOSTIC_POSITIONS' "(bytes x-y) " from the patch
  messages in unit-throw_messages.
- Windows clang (MinGW): link with LLD. unit-msgpack.cpp (C++11) and
  unit-regression2.cpp (C++20) have more than 32767 sections again
  (33363 and 33197), which GNU ld cannot link; LLD links them.

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

include/nlohmann/detail/conversions/to_json.hpp

@@ -13,7 +13,7 @@
     #include <optional> // optional
 #endif
 
-#include <iterator> // begin, end
+#include <iterator> // begin, end, make_move_iterator, move_iterator
 #include <memory> // allocator_traits
 #include <string> //  basic_string, char_traits
 #include <tuple> // tuple, get
@@ -48,6 +48,32 @@ namespace detail
  * leave j with the type of the new value, but the pointer to the destroyed old one.
  */
 
+// a move iterator over the elements of an rvalue container, unless they are
+// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a
+// std::move_iterator as value_type&&, which cannot bind to a const element
+template<typename Iterator>
+std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(Iterator it, std::true_type /*mutable*/)
+{
+    return std::make_move_iterator(it);
+}
+
+template<typename Iterator>
+Iterator make_move_iterator_if_mutable_impl(Iterator it, std::false_type /*mutable*/)
+{
+    return it;
+}
+
+template<typename Iterator>
+using is_mutable_iterator = std::integral_constant < bool,
+      !std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
+
+template<typename Iterator>
+auto make_move_iterator_if_mutable(Iterator it)
+-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
+{
+    return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
+}
+
 template<value_t> struct external_constructor;
 
 template<>
@@ -174,7 +200,7 @@ struct external_constructor<value_t::array>
         using std::begin;
         using std::end;
 
-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(std::make_move_iterator(begin(arr)), std::make_move_iterator(end(arr))));
+        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr))));
         j.replace_value(value_t::array, value);
     }
 
@@ -235,7 +261,7 @@ struct external_constructor<value_t::object>
         using std::begin;
         using std::end;
 
-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(std::make_move_iterator(begin(obj)), std::make_move_iterator(end(obj))));
+        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj))));
         j.replace_value(value_t::object, value);
     }
 
@@ -413,25 +439,27 @@ using is_movable_container_rvalue = negation<disjunction<
                                     std::is_const<T>,
                                     has_dedicated_to_json<T>,
                                     is_basic_json<T>,
-                                    is_range_view_type<T>,
                                     is_enum_keyed_map_type<T>,
                                     std::is_same<T, std::vector<bool>>>>;
 
-// rvalue array-like containers
+// rvalue array-like containers; object types are ruled out before views are
+// checked, as std::ranges::view<T> for the object_t of an ordered_json would
+// need that ordered_json to be complete (GCC 11, see #3312)
 template<typename BasicJsonType, typename T>
 using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
+      negation<is_compatible_object_type<BasicJsonType, T>>,
+      negation<is_range_view_type<T>>,
       is_compatible_array_type<BasicJsonType, T>,
       negation<disjunction<
       std::is_same<T, typename BasicJsonType::array_t>,
       std::is_same<T, typename BasicJsonType::binary_t>,
-      is_compatible_object_type<BasicJsonType, T>,
       is_compatible_string_type<BasicJsonType, T>,
       is_compatible_binary_type<BasicJsonType, T>>>>;
 
 // rvalue containers: their elements are moved instead of copied
 template<typename BasicJsonType, typename CompatibleArrayType,
          enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
-inline void to_json(BasicJsonType& j, CompatibleArrayType && arr)
+inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
 {
     external_constructor<value_t::array>::construct_moving(j, arr);
 }
@@ -509,7 +537,8 @@ inline void to_json(BasicJsonType& j, const EnumKeyedMap& map)
 }
 #endif
 
-// rvalue object-like containers
+// rvalue object-like containers (views have no key_type and mapped_type, so
+// they are no compatible object type)
 template<typename BasicJsonType, typename T>
 using is_rvalue_object_to_json = conjunction<is_movable_container_rvalue<T>,
       negation<std::is_same<T, typename BasicJsonType::object_t>>,
@@ -517,7 +546,7 @@ using is_rvalue_object_to_json = conjunction<is_movable_container_rvalue<T>,
 
 template<typename BasicJsonType, typename CompatibleObjectType,
          enable_if_t<is_rvalue_object_to_json<BasicJsonType, CompatibleObjectType>::value, int> = 0>
-inline void to_json(BasicJsonType& j, CompatibleObjectType && obj)
+inline void to_json(BasicJsonType& j, CompatibleObjectType && obj) // NOLINT(cppcoreguidelines-missing-std-forward)
 {
     external_constructor<value_t::object>::construct_moving(j, obj);
 }

include/nlohmann/detail/conversions/zmij.hpp

@@ -185,7 +185,7 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc
     const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
     std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
     // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses)
-    constexpr unsigned fractional_low_shift = static_cast<unsigned>(extra_shift);
+    constexpr auto fractional_low_shift = static_cast<unsigned>(extra_shift);
     constexpr unsigned fractional_high_shift = 64u - fractional_low_shift;
     const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift);
     std::uint64_t digit = 0;

include/nlohmann/detail/json_pointer.hpp

@@ -334,7 +334,7 @@ class json_pointer
                 {
                     break; // not a plain number: let strtoull decide
                 }
-                acc = static_cast<size_type>(acc * 10 + static_cast<size_type>(c - '0'));
+                acc = static_cast<size_type>((acc * 10) + static_cast<size_type>(c - '0'));
                 if (JSON_HEDLEY_UNLIKELY(i == s.size() - 1))
                 {
                     idx = acc;