Merge pull request #1803 from ericniebler/meta-diagnostic-cleanup

clean-up of the metaprogramming utilities and diagnostics

Author: ericniebler

include/exec/fork_join.hpp

@@ -265,7 +265,7 @@ namespace exec {
         return _child_completions_t{};
       } else if constexpr (!__decay_copyable_results_t::value) {
         return _ERROR_<
-          _WHAT_<>(PREDECESSOR_RESULTS_ARE_NOT_DECAY_COPYABLE),
+          _WHAT_(PREDECESSOR_RESULTS_ARE_NOT_DECAY_COPYABLE),
           _IN_ALGORITHM_(exec::fork_join_t)
         >();
       } else {

include/exec/into_tuple.hpp

@@ -23,15 +23,14 @@ namespace exec {
   namespace __into_tuple {
     using namespace STDEXEC;
 
-    template <
-      __mstring _Where = "In into_tuple: "_mstr,
-      __mstring _What = "The input sender must have at exactly one possible value completion"_mstr
-    >
-    struct _INVALID_ARGUMENT_TO_INTO_TUPLE_ { };
+    struct into_tuple_t;
+    struct _THE_INPUT_SENDER_MUST_HAVE_AT_EXACTLY_ONE_POSSIBLE_VALUE_COMPLETION_ { };
 
     template <class _Sender, class _Env>
     using __too_many_completions_error = __mexception<
-      _INVALID_ARGUMENT_TO_INTO_TUPLE_<>,
+      _WHAT_(_INVALID_ARGUMENT_),
+      _WHY_(_THE_INPUT_SENDER_MUST_HAVE_AT_EXACTLY_ONE_POSSIBLE_VALUE_COMPLETION_),
+      _WHERE_(_IN_ALGORITHM_, into_tuple_t),
       _WITH_PRETTY_SENDER_<_Sender>,
       _WITH_ENVIRONMENT_(_Env)
     >;

include/exec/just_from.hpp

@@ -46,7 +46,7 @@ namespace exec {
 
     template <class... Ts>
     using _error_t = STDEXEC::_ERROR_<
-      STDEXEC::_WHAT_<>(_diag_t),
+      STDEXEC::_WHAT_(_diag_t),
       STDEXEC::_WHERE_(STDEXEC::_IN_ALGORITHM_, JustTag),
       STDEXEC::_WITH_COMPLETION_SIGNATURE_<_set_tag_t(Ts...)>
     >;

include/exec/libdispatch_queue.hpp

@@ -124,7 +124,7 @@ namespace exec {
             __libdispatch_bulk::transform_bulk{*sched.queue_}, std::forward<Sender>(sndr));
         } else {
           return STDEXEC::__not_a_sender<
-            STDEXEC::_WHAT_<>(CANNOT_DISPATCH_THE_BULK_ALGORITHM_TO_THE_LIBDISPATCH_SCHEDULER),
+            STDEXEC::_WHAT_(CANNOT_DISPATCH_THE_BULK_ALGORITHM_TO_THE_LIBDISPATCH_SCHEDULER),
             STDEXEC::_WHY_(BECAUSE_THERE_IS_NO_LIBDISPATCH_SCHEDULER_IN_THE_ENVIRONMENT),
             STDEXEC::_WHERE_(STDEXEC::_IN_ALGORITHM_, STDEXEC::bulk_t),
             STDEXEC::_TO_FIX_THIS_ERROR_(

include/exec/repeat_n.hpp

@@ -146,7 +146,7 @@ namespace exec {
     };
 
     struct repeat_n_t;
-    struct _REPEAT_N_EXPECTS_A_SENDER_OF_VOID_;
+    struct _THE_INPUT_SENDER_MUST_HAVE_VOID_VALUE_COMPLETION_;
 
     template <class _Child, class... _Args>
     using __values_t =
@@ -155,8 +155,9 @@ namespace exec {
         (sizeof...(_Args) == 0),
         completion_signatures<>,
         __mexception<
-          _REPEAT_N_EXPECTS_A_SENDER_OF_VOID_,
+          _WHAT_(_INVALID_ARGUMENT_),
           _WHERE_(_IN_ALGORITHM_, repeat_n_t),
+          _WHY_(_THE_INPUT_SENDER_MUST_HAVE_VOID_VALUE_COMPLETION_),
           _WITH_PRETTY_SENDER_<_Child>
         >
       >;
@@ -187,12 +188,12 @@ namespace exec {
       static constexpr auto connect = //
         []<class _Receiver, class _Sender>(_Sender &&__sndr, _Receiver &&__rcvr) noexcept(
           noexcept(__opstate(0, STDEXEC::__get<2>(__declval<_Sender>()), __declval<_Receiver>()))) {
-        const std::size_t __count = STDEXEC::__get<1>(__sndr);
-        return __opstate(
-          __count,
-          STDEXEC::__get<2>(static_cast<_Sender &&>(__sndr)),
-          static_cast<_Receiver &&>(__rcvr));
-      };
+          const std::size_t __count = STDEXEC::__get<1>(__sndr);
+          return __opstate(
+            __count,
+            STDEXEC::__get<2>(static_cast<_Sender &&>(__sndr)),
+            static_cast<_Receiver &&>(__rcvr));
+        };
     };
 
     struct repeat_n_t {

include/exec/repeat_until.hpp

@@ -181,10 +181,9 @@ namespace exec {
           completion_signatures<set_value_t()>
         >,
         __mexception<
-          _WHAT_<>(
-            _INVALID_ARGUMENT_,
-            _EXPECTING_A_SENDER_OF_ONE_VALUE_THAT_IS_CONVERTIBLE_TO_BOOL_),
+          _WHAT_(_INVALID_ARGUMENT_),
           _WHERE_(_IN_ALGORITHM_, repeat_until_t),
+          _WHY_(_EXPECTING_A_SENDER_OF_ONE_VALUE_THAT_IS_CONVERTIBLE_TO_BOOL_),
           _WITH_PRETTY_SENDER_<_Child>
         >
       >;
@@ -260,7 +259,7 @@ namespace exec {
           return repeat_until_t()(then(static_cast<__child_t &&>(__child), _never{}));
         } else {
           return __not_a_sender<
-            _WHAT_<>(_INVALID_ARGUMENT_, _EXPECTING_A_SENDER_OF_VOID_),
+            _WHAT_(_INVALID_ARGUMENT_, _EXPECTING_A_SENDER_OF_VOID_),
             _WHERE_(_IN_ALGORITHM_, repeat_until_t),
             _WITH_PRETTY_SENDER_<__child_t>,
             _WITH_ENVIRONMENT_(_Env)

include/exec/reschedule.hpp

@@ -19,19 +19,19 @@
 
 namespace exec {
   namespace __resched {
-
     using namespace STDEXEC;
 
-    template <
-      __mstring _Where = "In reschedule() ..."_mstr,
-      __mstring _What =
-        "The execution environment does not have a current scheduler on which to reschedule."_mstr
-    >
-    struct _INVALID_RESCHEDULE_NO_SCHEDULER_ { };
+    struct reschedule_t;
+    struct _CANNOT_RESCHEDULE_ { };
+    struct _THE_CURRENT_EXECUTION_ENVIRONMENT_DOESNT_HAVE_A_SCHEDULER_ { };
 
     template <class _Env>
-    using __no_scheduler_error =
-      __mexception<_INVALID_RESCHEDULE_NO_SCHEDULER_<>, _WITH_ENVIRONMENT_(_Env)>;
+    using __no_scheduler_error = __mexception<
+      _WHAT_(_CANNOT_RESCHEDULE_),
+      _WHY_(_THE_CURRENT_EXECUTION_ENVIRONMENT_DOESNT_HAVE_A_SCHEDULER_),
+      _WHERE_(_IN_ALGORITHM_, reschedule_t),
+      _WITH_ENVIRONMENT_(_Env)
+    >;
 
     template <class _Env>
     using __schedule_sender_t = schedule_result_t<__call_result_t<get_scheduler_t, _Env>>;
@@ -75,7 +75,7 @@ namespace exec {
       constexpr auto operator==(const __scheduler&) const noexcept -> bool = default;
     };
 
-    struct __reschedule_t {
+    struct reschedule_t {
       template <sender _Sender>
       constexpr auto operator()(_Sender&& __sndr) const {
         return STDEXEC::continues_on(static_cast<_Sender&&>(__sndr), __resched::__scheduler{});
@@ -87,5 +87,5 @@ namespace exec {
     };
   } // namespace __resched
 
-  inline constexpr auto reschedule = __resched::__reschedule_t{};
+  inline constexpr auto reschedule = __resched::reschedule_t{};
 } // namespace exec

include/exec/sequence/merge_each.hpp

@@ -39,6 +39,7 @@
 namespace exec {
   namespace __merge_each {
     using namespace STDEXEC;
+    struct merge_each_t;
 
     struct __env_with_inplace_stop_token_t {
       auto operator()(inplace_stop_token& __stop_token) const noexcept {
@@ -756,7 +757,7 @@ namespace exec {
     template <class _OperationBase>
     using __receive_nested_values_t = __minvoke<__mtry_q<__receive_nested_values>, _OperationBase>;
 
-    struct _INVALID_ARGUMENT_TO_MERGE_WITH_REQUIRES_A_SEQUENCE_OF_SEQUENCES_ { };
+    struct _MERGE_WITH_REQUIRES_A_SEQUENCE_OF_SEQUENCES_ { };
 
     template <class _Sequence, class _Sender, class... _Env>
     struct __value_completions_error {
@@ -765,7 +766,9 @@ namespace exec {
         sizeof...(_Env) == 0 && sizeof...(_Args) == 1 && (dependent_sender<_Args> && ...),
         STDEXEC::__mexception<dependent_sender_error, _WITH_PRETTY_SENDER_<_Args>...>,
         STDEXEC::__mexception<
-          _INVALID_ARGUMENT_TO_MERGE_WITH_REQUIRES_A_SEQUENCE_OF_SEQUENCES_,
+          _WHAT_(_INVALID_ARGUMENT_),
+          _WHERE_(_IN_ALGORITHM_, merge_each_t),
+          _WHY_(_MERGE_WITH_REQUIRES_A_SEQUENCE_OF_SEQUENCES_),
           _WITH_PRETTY_SEQUENCE_<_Sequence>,
           _WITH_PRETTY_SENDER_<_Sender>,
           __fn_t<_WITH_ENVIRONMENT_, _Env>...,

include/exec/sequence_senders.hpp

@@ -226,16 +226,10 @@ namespace exec {
     struct __item_types { };
   } // namespace __debug
 
-  namespace __errs {
-    using namespace STDEXEC;
-    inline constexpr __mstring __unrecognized_sequence_type_diagnostic =
-      "The given type cannot be used as a sequence with the given environment "
-      "because the attempt to compute the item types failed."_mstr;
-  } // namespace __errs
-
-  template <STDEXEC::__mstring _Diagnostic = __errs::__unrecognized_sequence_type_diagnostic>
   struct _UNRECOGNIZED_SEQUENCE_TYPE_;
 
+  struct _FAILED_TO_COMPUTE_SEQUENCE_ITEM_TYPES_ { };
+
 #if STDEXEC_NO_STD_CONSTEXPR_EXCEPTIONS()
 
   template <class... _What, class... _Values>
@@ -268,7 +262,8 @@ namespace exec {
 
   template <class _Sequence, class... _Env>
   using __unrecognized_sequence_error_t = STDEXEC::__mexception<
-    _UNRECOGNIZED_SEQUENCE_TYPE_<>,
+    STDEXEC::_WHAT_(_UNRECOGNIZED_SEQUENCE_TYPE_),
+    STDEXEC::_WHY_(_FAILED_TO_COMPUTE_SEQUENCE_ITEM_TYPES_),
     _WITH_PRETTY_SEQUENCE_<_Sequence>,
     STDEXEC::_WITH_ENVIRONMENT_(_Env)...
   >;
@@ -301,6 +296,7 @@ namespace exec {
 
     template <class _Sequence, class... _Env>
     concept __with_member_alias = __mvalid<__member_alias_t, _Sequence, _Env...>;
+
     template <class _Sequence, class... _Env>
     concept __with_consteval_static_member =
       __mvalid<__consteval_static_member_result_t, _Sequence, _Env...>;
@@ -393,12 +389,12 @@ namespace exec {
   concept sequence_sender = STDEXEC::sender_in<_Sequence, _Env...>
                          && enable_sequence_sender<STDEXEC::__decay_t<_Sequence>>;
 
-  template <class _Item>
   struct _SEQUENCE_ITEM_IS_NOT_A_WELL_FORMED_SENDER_ { };
 
   template <class _Sequence, class _Item>
   constexpr auto __check_item(_Item*) -> STDEXEC::__mexception<
-    _SEQUENCE_ITEM_IS_NOT_A_WELL_FORMED_SENDER_<_Item>,
+    STDEXEC::_WHAT_(_SEQUENCE_ITEM_IS_NOT_A_WELL_FORMED_SENDER_),
+    STDEXEC::_WITH_PRETTY_SENDER_<_Item>,
     _WITH_PRETTY_SEQUENCE_<_Sequence>
   >;
 
@@ -410,13 +406,17 @@ namespace exec {
     requires STDEXEC::__merror<_Items>
   auto __check_items(_Items*) -> _Items;
 
-  template <class _Item>
   struct _SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_ { };
 
+  template <template <class...> class _Class>
+  struct _EXPECTED_A_SPECIALIZATION_OF_ { };
+
   template <class _Sequence, class _Items>
     requires(!STDEXEC::__merror<_Items>)
   auto __check_items(_Items*) -> STDEXEC::__mexception<
-    _SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_<_Items>,
+    STDEXEC::_WHAT_(_SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_),
+    STDEXEC::_WHY_(_EXPECTED_A_SPECIALIZATION_OF_<item_types>),
+    STDEXEC::_WITH_TYPE_<_Items>,
     _WITH_PRETTY_SEQUENCE_<_Sequence>
   >;
 
@@ -435,12 +435,14 @@ namespace exec {
     requires STDEXEC::__merror<_Sequence>
   auto __check_sequence(_Sequence*) -> _Sequence;
 
-  struct _SEQUENCE_GET_ITEM_TYPES_IS_NOT_WELL_FORMED_ { };
+  struct _ERROR_WHILE_COMPUTING_THE_SEQUENCE_ITEM_TYPES_ { };
+  struct _THE_CALL_TO_GET_ITEM_TYPES_IS_ILL_FORMED_ { };
 
   template <class _Sequence>
     requires(!STDEXEC::__merror<_Sequence>) && (!STDEXEC::__mvalid<__item_types_of_t, _Sequence>)
   auto __check_sequence(_Sequence*) -> STDEXEC::__mexception<
-    _SEQUENCE_GET_ITEM_TYPES_IS_NOT_WELL_FORMED_,
+    STDEXEC::_WHAT_(_ERROR_WHILE_COMPUTING_THE_SEQUENCE_ITEM_TYPES_),
+    STDEXEC::_WHY_(_THE_CALL_TO_GET_ITEM_TYPES_IS_ILL_FORMED_),
     _WITH_PRETTY_SEQUENCE_<_Sequence>
   >;
 
@@ -525,12 +527,12 @@ namespace exec {
     _Data __data_{};
   };
 
-  template <class _Item>
   struct _MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_ { };
 
   template <class _Receiver, class _Item>
   constexpr auto __try_item(_Item*) -> STDEXEC::__mexception<
-    _MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_<_Item>,
+    STDEXEC::_WHAT_(_MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_),
+    STDEXEC::_WITH_PRETTY_SENDER_<_Item>,
     STDEXEC::_WITH_RECEIVER_(_Receiver)
   >;
 

include/exec/static_thread_pool.hpp

@@ -302,7 +302,7 @@ namespace exec {
             return __apply(_transform_bulk{*sched.pool_}, static_cast<Sender&&>(sndr));
           } else {
             return STDEXEC::__not_a_sender<
-              STDEXEC::_WHAT_<>(
+              STDEXEC::_WHAT_(
                 CANNOT_DISPATCH_THE_BULK_ALGORITHM_TO_THE_STATIC_THREAD_POOL_SCHEDULER),
               STDEXEC::_WHY_(BECAUSE_THERE_IS_NO_STATIC_THREAD_POOL_SCHEDULER_IN_THE_ENVIRONMENT),
               STDEXEC::_WHERE_(STDEXEC::_IN_ALGORITHM_, tag_of_t<Sender>),
@@ -323,7 +323,7 @@ namespace exec {
             return __apply(_transform_iterate{*sched.pool_}, static_cast<Sender&&>(sndr));
           } else {
             return STDEXEC::__not_a_sender<
-              STDEXEC::_WHAT_<>(
+              STDEXEC::_WHAT_(
                 CANNOT_DISPATCH_THE_ITERATE_ALGORITHM_TO_THE_STATIC_THREAD_POOL_SCHEDULER),
               STDEXEC::_WHY_(BECAUSE_THERE_IS_NO_STATIC_THREAD_POOL_SCHEDULER_IN_THE_ENVIRONMENT),
               STDEXEC::_WHERE_(STDEXEC::_IN_ALGORITHM_, exec::iterate_t),