[NFC][libc++][format] Uses qualified calls.

[Mordante]

Summary

Changes all unqualified calls to __throw_format_error to use a qualified
call.

[philnik]

LGTM with CI passing.

libcxx/include/__format/format_functions.h

__parse_ = [](basic_format_parse_context<_CharT>& __parse_ctx) {
       formatter<_Tp, _CharT> __f;
       __parse_ctx.advance_to(__f.parse(__parse_ctx));
     };
   }
 
   // Before calling __parse the proper handler needs to be set with __enable.
   // The default handler isn't a core constant expression.
   _LIBCPP_HIDE_FROM_ABI constexpr __compile_time_handle()
-      : __parse_([](basic_format_parse_context<_CharT>&) { __throw_format_error("Not a handle"); }) {}
+      : __parse_([](basic_format_parse_context<_CharT>&) { std::__throw_format_error("Not a handle"); }) {}
 
 private:
   void (*__parse_)(basic_format_parse_context<_CharT>&);
 };
 
 // Dummy format_context only providing the parts used during constant
 // validation of the basic_format_string.
 template <class _CharT>
public:
   struct iterator {
     _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator=(_CharT) { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr iterator& operator*() { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr iterator operator++(int) { return *this; }
   };
 
   _LIBCPP_HIDE_FROM_ABI constexpr __arg_t arg(size_t __id) const {
     if (__id >= __size_)
-      __throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("Argument index out of bounds");
     return __args_[__id];
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const __compile_time_handle<_CharT>& __handle(size_t __id) const {
     if (__id >= __size_)
-      __throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("Argument index out of bounds");
     return __handles_[__id];
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr iterator out() { return {}; }
   _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(iterator) {}
 
 private:
   const __arg_t* __args_;
   const __compile_time_handle<_CharT>* __handles_;
   size_t __size_;
 };
 
 _LIBCPP_HIDE_FROM_ABI
 constexpr void __compile_time_validate_integral(__arg_t __type) {
   switch (__type) {
   case __arg_t::__int:
   case __arg_t::__long_long:
   case __arg_t::__i128:
   case __arg_t::__unsigned:
   case __arg_t::__unsigned_long_long:
   case __arg_t::__u128:
     return;
 
   default:
-    __throw_format_error("Argument isn't an integral type");
+    std::__throw_format_error("Argument isn't an integral type");
   }
 }
 
 // _HasPrecision does the formatter have a precision?
 template <class _CharT, class _Tp, bool _HasPrecision = false>
 _LIBCPP_HIDE_FROM_ABI constexpr void
 __compile_time_validate_argument(basic_format_parse_context<_CharT>& __parse_ctx,
                                  __compile_time_basic_format_context<_CharT>& __ctx) {

 
 // This function is not user facing, so it can directly use the non-standard types of the "variant".
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_format_parse_context<_CharT>& __parse_ctx,
                                                                      __compile_time_basic_format_context<_CharT>& __ctx,
                                                                      __arg_t __type) {
   switch (__type) {
   case __arg_t::__none:
-    __throw_format_error("Invalid argument");
+    std::__throw_format_error("Invalid argument");
   case __arg_t::__boolean:
     return __format::__compile_time_validate_argument<_CharT, bool>(__parse_ctx, __ctx);
   case __arg_t::__char_type:
     return __format::__compile_time_validate_argument<_CharT, _CharT>(__parse_ctx, __ctx);
   case __arg_t::__int:
     return __format::__compile_time_validate_argument<_CharT, int>(__parse_ctx, __ctx);
   case __arg_t::__long_long:
     return __format::__compile_time_validate_argument<_CharT, long long>(__parse_ctx, __ctx);
   case __arg_t::__i128:
 #      ifndef _LIBCPP_HAS_NO_INT128
     return __format::__compile_time_validate_argument<_CharT, __int128_t>(__parse_ctx, __ctx);
 #      else
-    __throw_format_error("Invalid argument");
+    std::__throw_format_error("Invalid argument");
 #      endif
     return;
   case __arg_t::__unsigned:
     return __format::__compile_time_validate_argument<_CharT, unsigned>(__parse_ctx, __ctx);
   case __arg_t::__unsigned_long_long:
     return __format::__compile_time_validate_argument<_CharT, unsigned long long>(__parse_ctx, __ctx);
   case __arg_t::__u128:
 #      ifndef _LIBCPP_HAS_NO_INT128
     return __format::__compile_time_validate_argument<_CharT, __uint128_t>(__parse_ctx, __ctx);
 #      else
-    __throw_format_error("Invalid argument");
+    std::__throw_format_error("Invalid argument");
 #      endif
     return;
   case __arg_t::__float:
     return __format::__compile_time_validate_argument<_CharT, float, true>(__parse_ctx, __ctx);
   case __arg_t::__double:
     return __format::__compile_time_validate_argument<_CharT, double, true>(__parse_ctx, __ctx);
   case __arg_t::__long_double:
     return __format::__compile_time_validate_argument<_CharT, long double, true>(__parse_ctx, __ctx);
   case __arg_t::__const_char_type_ptr:
     return __format::__compile_time_validate_argument<_CharT, const _CharT*, true>(__parse_ctx, __ctx);
   case __arg_t::__string_view:
     return __format::__compile_time_validate_argument<_CharT, basic_string_view<_CharT>, true>(__parse_ctx, __ctx);
   case __arg_t::__ptr:
     return __format::__compile_time_validate_argument<_CharT, const void*>(__parse_ctx, __ctx);
   case __arg_t::__handle:
-    __throw_format_error("Handle should use __compile_time_validate_handle_argument");
+    std::__throw_format_error("Handle should use __compile_time_validate_handle_argument");
   }
-  __throw_format_error("Invalid argument");
+  std::__throw_format_error("Invalid argument");
 }
 
 template <class _CharT, class _ParseCtx, class _Ctx>
 _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
 __handle_replacement_field(const _CharT* __begin, const _CharT* __end,
                            _ParseCtx& __parse_ctx, _Ctx& __ctx) {
   __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   bool __parse = *__r.__ptr == _CharT(':');
   switch (*__r.__ptr) {
   case _CharT(':'):
     // The arg-id has a format-specifier, advance the input to the format-spec.
     __parse_ctx.advance_to(__r.__ptr + 1);
     break;
   case _CharT('}'):
     // The arg-id has no format-specifier.
     __parse_ctx.advance_to(__r.__ptr);
     break;
   default:
-    __throw_format_error(
-        "The replacement field arg-id should terminate at a ':' or '}'");
+    std::__throw_format_error("The replacement field arg-id should terminate at a ':' or '}'");
   }
 
   if constexpr (same_as<_Ctx, __compile_time_basic_format_context<_CharT>>) {
     __arg_t __type = __ctx.arg(__r.__value);
     if (__type == __arg_t::__handle)
       __ctx.__handle(__r.__value).__parse(__parse_ctx);
     else
         __format::__compile_time_visit_format_arg(__parse_ctx, __ctx, __type);
   } else
     _VSTD::__visit_format_arg(
         [&](auto __arg) {
           if constexpr (same_as<decltype(__arg), monostate>)
-            __throw_format_error("Argument index out of bounds");
+            std::__throw_format_error("Argument index out of bounds");
           else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Ctx>::handle>)
             __arg.format(__parse_ctx, __ctx);
           else {
             formatter<decltype(__arg), _CharT> __formatter;
             if (__parse)
               __parse_ctx.advance_to(__formatter.parse(__parse_ctx));
             __ctx.advance_to(__formatter.format(__arg, __ctx));
           }
         },
         __ctx.arg(__r.__value));
 
   __begin = __parse_ctx.begin();
   if (__begin == __end || *__begin != _CharT('}'))
-    __throw_format_error("The replacement field misses a terminating '}'");
+    std::__throw_format_error("The replacement field misses a terminating '}'");
 
   return ++__begin;
 }
 
 template <class _ParseCtx, class _Ctx>
 _LIBCPP_HIDE_FROM_ABI constexpr typename _Ctx::iterator
 __vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
   using _CharT = typename _ParseCtx::char_type;
   static_assert(same_as<typename _Ctx::char_type, _CharT>);
 
   const _CharT* __begin = __parse_ctx.begin();
   const _CharT* __end = __parse_ctx.end();
   typename _Ctx::iterator __out_it = __ctx.out();
   while (__begin != __end) {
     switch (*__begin) {
     case _CharT('{'):
       ++__begin;
       if (__begin == __end)
-        __throw_format_error("The format string terminates at a '{'");
+        std::__throw_format_error("The format string terminates at a '{'");
 
       if (*__begin != _CharT('{')) [[likely]] {
         __ctx.advance_to(_VSTD::move(__out_it));
         __begin =
             __handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
         __out_it = __ctx.out();
 
         // The output is written and __begin points to the next character. So
         // start the next iteration.
         continue;
       }
       // The string is an escape character.
       break;
 
     case _CharT('}'):
       ++__begin;
       if (__begin == __end || *__begin != _CharT('}'))
-        __throw_format_error(
-            "The format string contains an invalid escape sequence");
+        std::__throw_format_error("The format string contains an invalid escape sequence");
 
       break;
     }
 
     // Copy the character to the output verbatim.
     *__out_it++ = *__begin++;
   }
   return __out_it;

libcxx/include/__format/format_parse_context.h

_LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
     return __end_;
   }
   _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(const_iterator __it) {
     __begin_ = __it;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr size_t next_arg_id() {
     if (__indexing_ == __manual)
-      __throw_format_error("Using automatic argument numbering in manual "
-                           "argument numbering mode");
+      std::__throw_format_error("Using automatic argument numbering in manual argument numbering mode");
 
     if (__indexing_ == __unknown)
       __indexing_ = __automatic;
     return __next_arg_id_++;
   }
   _LIBCPP_HIDE_FROM_ABI constexpr void check_arg_id(size_t __id) {
     if (__indexing_ == __automatic)
-      __throw_format_error("Using manual argument numbering in automatic "
-                           "argument numbering mode");
+      std::__throw_format_error("Using manual argument numbering in automatic argument numbering mode");
 
     if (__indexing_ == __unknown)
       __indexing_ = __manual;
 
     // Throws an exception to make the expression a non core constant
     // expression as required by:
     // [format.parse.ctx]/11
     //   Remarks: Call expressions where id >= num_args_ are not core constant
     //   expressions ([expr.const]).
     // Note: the Throws clause [format.parse.ctx]/10 doesn't specify the
     // behavior when id >= num_args_.
     if (is_constant_evaluated() && __id >= __num_args_)
-      __throw_format_error("Argument index outside the valid range");
+      std::__throw_format_error("Argument index outside the valid range");
   }
 
 private:
   iterator __begin_;
   iterator __end_;
   enum _Indexing { __unknown, __manual, __automatic };
   _Indexing __indexing_;
   size_t __next_arg_id_;

libcxx/include/__format/format_string.h

if (__begin != __end_input && *__begin >= _CharT('0') &&
      * - Does the 10th digit exceed the maximum allowed value?
      * - Are there more than 10 digits?
      * (More than 10 digits always overflows the maximum.)
      */
     uint64_t __v = uint64_t(__value) * 10 + *__begin++ - _CharT('0');
     if (__v > __number_max ||
         (__begin != __end_input && *__begin >= _CharT('0') &&
          *__begin <= _CharT('9')))
-      __throw_format_error("The numeric value of the format-spec is too large");
+      std::__throw_format_error("The numeric value of the format-spec is too large");
 
     __value = __v;
   }
 
   return {__begin, __value};
 }
 
 /**
__parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
   case _CharT(':'):
     // This case is conditionally valid. It's allowed in an arg-id in the
     // replacement-field, but not in the std-format-spec. The caller can
     // provide a better diagnostic, so accept it here unconditionally.
   case _CharT('}'):
     return __detail::__parse_automatic(__begin, __end, __parse_ctx);
   }
   if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-    __throw_format_error(
-        "The arg-id of the format-spec starts with an invalid character");
+    std::__throw_format_error("The arg-id of the format-spec starts with an invalid character");
 
   return __detail::__parse_manual(__begin, __end, __parse_ctx);
 }
 
 } // namespace __format
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_STRING_H

libcxx/include/__format/parser_std_format_spec.h

 namespace __format_spec {
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result< _CharT>
 __parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
-    __throw_format_error("End of input while parsing format-spec arg-id");
+    std::__throw_format_error("End of input while parsing format-spec arg-id");
 
   __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
-    __throw_format_error("Invalid arg-id");
+    std::__throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
 __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   // [format.string.std]/8
   //   If the corresponding formatting argument is not of integral type...
   // This wording allows char and bool too. LWG-3720 changes the wording to
   //    If the corresponding formatting argument is not of standard signed or
   //    unsigned integer type,
   // This means the 128-bit will not be valid anymore.
   // TODO FMT Verify this resolution is accepted and add a test to verify
   //          128-bit integrals fail and switch to visit_format_arg.
   return _VSTD::__visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (integral<_Type>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
-              __throw_format_error("A format-spec arg-id replacement shouldn't "
-                                   "have a negative value");
+              std::__throw_format_error("A format-spec arg-id replacement shouldn't have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) >
               static_cast<_CT>(__format::__number_max))
-            __throw_format_error("A format-spec arg-id replacement exceeds "
-                                 "the maximum supported value");
+            std::__throw_format_error("A format-spec arg-id replacement exceeds the maximum supported value");
 
           return __arg;
         } else if constexpr (same_as<_Type, monostate>)
-          __throw_format_error("Argument index out of bounds");
+          std::__throw_format_error("Argument index out of bounds");
         else
-          __throw_format_error("A format-spec arg-id replacement argument "
-                               "isn't an integral type");
+          std::__throw_format_error("A format-spec arg-id replacement argument isn't an integral type");
       },
       __format_arg);
 }
 
 /// These fields are a filter for which elements to parse.
 ///
 /// They default to false so when a new field is added it needs to be opted in
 /// explicitly.
_LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields)
 
     if (__fields.__type_) {
       __parse_type(__begin);
 
       // When __type_ is false the calling parser is expected to do additional
       // parsing. In that case that parser should do the end of format string
       // validation.
       if (__begin != __end && *__begin != _CharT('}'))
-        __throw_format_error("The format-spec should consume the input or end with a '}'");
+        std::__throw_format_error("The format-spec should consume the input or end with a '}'");
     }
 
     return __begin;
   }
 
   /// \returns the `__parsed_specifications` with the resolved dynamic sizes..
   _LIBCPP_HIDE_FROM_ABI
   __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
private:
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(const _CharT*& __begin, const _CharT* __end) {
     _LIBCPP_ASSERT(__begin != __end, "when called with an empty input the function will cause "
                                      "undefined behavior by evaluating data not in the input");
     if (__begin + 1 != __end) {
       if (__parse_alignment(*(__begin + 1))) {
         if (*__begin == _CharT('{') || *__begin == _CharT('}'))
-          __throw_format_error("The format-spec fill field contains an invalid character");
+          std::__throw_format_error("The format-spec fill field contains an invalid character");
 
         __fill_ = *__begin;
         __begin += 2;
         return true;
       }
     }
 
     if (!__parse_alignment(*__begin))
_LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(const _CharT*& __begin) {
     if (__alignment_ == __alignment::__default)
       __alignment_ = __alignment::__zero_padding;
     ++__begin;
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(const _CharT*& __begin, const _CharT* __end, auto& __parse_ctx) {
     if (*__begin == _CharT('0'))
-      __throw_format_error("A format-spec width field shouldn't have a leading zero");
+      std::__throw_format_error("A format-spec width field shouldn't have a leading zero");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __width_as_arg_ = true;
       __width_ = __r.__value;
       __begin = __r.__ptr;
       return true;
     }
private:
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(const _CharT*& __begin, const _CharT* __end,
                                                          auto& __parse_ctx) {
     if (*__begin != _CharT('.'))
       return false;
 
     ++__begin;
     if (__begin == __end)
-      __throw_format_error("End of input while parsing format-spec precision");
+      std::__throw_format_error("End of input while parsing format-spec precision");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __precision_as_arg_ = true;
       __precision_ = __arg_id.__value;
       __begin = __arg_id.__ptr;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-      __throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
+      std::__throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
 
     __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
     __precision_ = __r.__value;
     __precision_as_arg_ = false;
     __begin = __r.__ptr;
     return true;
   }