__completion_signatures_of_t requires that get_completion_signatures<S,E...>() is a constant expression

Author: ericniebler

include/exec/sequence_senders.hpp

@@ -557,8 +557,7 @@ namespace experimental::execution
 #endif
 
   template <class _Data, class... _What>
-  struct __sequence_type_check_failure  //
-    : STDEXEC::__compile_time_error<__sequence_type_check_failure<_Data, _What...>>
+  struct __sequence_type_check_failure : STDEXEC::__compile_time_error
   {
     static_assert(std::is_nothrow_move_constructible_v<_Data>,
                   "The data member of sender_type_check_failure must be nothrow move "
@@ -570,16 +569,14 @@ namespace experimental::execution
       : __data_(static_cast<_Data&&>(data))
     {}
 
-   private:
-    friend struct STDEXEC::__compile_time_error<__sequence_type_check_failure>;
-
     [[nodiscard]]
-    constexpr auto what() const noexcept -> char const *
+    constexpr auto what() const noexcept -> char const *  // NOLINT(modernize-use-override)
     {
       return "This sequence sender is not well-formed. It does not meet the requirements of a "
              "sequence sender type.";
     }
 
+    // public so that __sequence_type_check_failure is a structural type
     _Data __data_{};
   };
 
@@ -845,10 +842,9 @@ namespace experimental::execution
           return STDEXEC::connect(static_cast<next_sender_of_t<_Receiver, __tfx_seq_t>&&>(__next),
                                   __stopped_means_break<_Receiver>{
                                     static_cast<_Receiver&&>(__rcvr)});
-          // NOLINTNEXTLINE(bugprone-branch-clone)
         }
         else if constexpr (__subscribable_with_static_member<__tfx_seq_t, _Receiver>)
-        {
+        {  // NOLINT(bugprone-branch-clone)
           return __tfx_seq.subscribe(static_cast<__tfx_seq_t&&>(__tfx_seq),
                                      static_cast<_Receiver&&>(__rcvr));
         }

include/stdexec/__detail/__concepts.hpp

@@ -97,6 +97,19 @@ namespace STDEXEC
   template <class _Ay, template <class...> class _Ty>
   concept __is_not_instance_of = !__is_instance_of<_Ay, _Ty>;
 
+  namespace __detail
+  {
+    template <auto>
+    using __is_nttp = void;
+    template <class _Ty, template <_Ty> class>
+    using __nttp_test = void;
+  }  // namespace __detail
+
+  template <class _Ty>
+  concept __structural = requires { typename __detail::__nttp_test<_Ty, __detail::__is_nttp>; };
+
+  static_assert(__structural<int>);
+
   namespace __std
   {
 

include/stdexec/__detail/__diagnostics.hpp

@@ -144,13 +144,14 @@ namespace STDEXEC
                  _WITH_PRETTY_SENDER_<_Sender>,
                  _WITH_ENVIRONMENT_(_Env)...>;
 
-#if __cpp_lib_constexpr_exceptions                                                                 \
-  >= 2025'02L  // constexpr exception types, https://wg21.link/p3378
+#if __cpp_lib_constexpr_exceptions >= 2025'02L
 
+  // constexpr stdlib exception types, https://wg21.link/p3378
   using __exception = ::std::exception;
 
-#elif __cpp_constexpr >= 2024'11L  // constexpr virtual functions
+#elif __cpp_constexpr >= 2019'07L
 
+  // constexpr virtual functions
   struct __exception
   {
     constexpr __exception() noexcept = default;
@@ -163,8 +164,9 @@ namespace STDEXEC
     }
   };
 
-#else  // no constexpr virtual functions:
+#else
 
+  // no constexpr virtual functions
   struct __exception
   {
     constexpr __exception() noexcept = default;
@@ -176,23 +178,13 @@ namespace STDEXEC
     }
   };
 
-#endif  // __cpp_lib_constexpr_exceptions >= 2025'02L
+#endif
 
-  template <class _Derived>
   struct __compile_time_error : __exception
-  {
-    constexpr __compile_time_error() = default;  // NOLINT (bugprone-crtp-constructor-accessibility)
-
-    [[nodiscard]]
-    constexpr auto what() const noexcept -> char const *
-    {
-      return static_cast<_Derived const *>(this)->what();
-    }
-  };
+  { };
 
   template <class _Data, class... _What>
-  struct __sender_type_check_failure  //
-    : __compile_time_error<__sender_type_check_failure<_Data, _What...>>
+  struct __sender_type_check_failure : __compile_time_error
   {
     static_assert(std::is_nothrow_move_constructible_v<_Data>,
                   "The data member of sender_type_check_failure must be nothrow move "
@@ -204,34 +196,24 @@ namespace STDEXEC
       : __data_(static_cast<_Data &&>(data))
     {}
 
-   private:
-    friend struct __compile_time_error<__sender_type_check_failure>;
-
     [[nodiscard]]
-    constexpr auto what() const noexcept -> char const *
+    constexpr auto what() const noexcept -> char const *  // NOLINT(modernize-use-override)
     {
       return "This sender is not well-formed. It does not meet the requirements of a sender type.";
     }
 
+    // public so that __sender_type_check_failure is a structural type
     _Data __data_{};
   };
 
-  struct dependent_sender_error : __compile_time_error<dependent_sender_error>
+  struct dependent_sender_error : __compile_time_error
   {
-    constexpr explicit dependent_sender_error(char const *what) noexcept
-      : what_(what)
-    {}
-
-   private:
-    friend struct __compile_time_error<dependent_sender_error>;
-
     [[nodiscard]]
-    constexpr auto what() const noexcept -> char const *
+    constexpr auto what() const noexcept -> char const *  // NOLINT(modernize-use-override)
     {
-      return what_;
+      return "This sender needs to know its execution environment before it can "
+             "know how it will complete.";
     }
-
-    char const *what_;
   };
 
   // A specialization of _ERROR_ to be used to report dependent sender. It inherits
@@ -257,11 +239,8 @@ namespace STDEXEC
     using __errors                 = _ERROR_;
     using __all                    = _ERROR_;
 
-    constexpr _ERROR_() noexcept
-      : dependent_sender_error{"This sender needs to know its execution environment before it can "
-                               "know how it will "
-                               "complete."}
-    {}
+    constexpr _ERROR_()  = default;
+    constexpr ~_ERROR_() = default;
 
     STDEXEC_ATTRIBUTE(host, device) constexpr auto operator+() const -> _ERROR_;
 
@@ -274,6 +253,8 @@ namespace STDEXEC
     constexpr auto operator,(const _ERROR_<Other...> &) const -> _ERROR_<Other...>;
   };
 
+  static_assert(__structural<_ERROR_<dependent_sender_error>>);
+
   // By making __dependent_sender_error_t an alias for _ERROR_<...>, we ensure that
   // it will get propagated correctly through various metafunctions.
   template <class _Sender>

include/stdexec/__detail/__get_completion_signatures.hpp

@@ -305,7 +305,7 @@ namespace STDEXEC
   template <class _Sender, class... _Env>
     requires enable_sender<__decay_t<_Sender>>
   using __completion_signatures_of_t =
-    decltype(STDEXEC::get_completion_signatures<_Sender, _Env...>());
+    __mtypeof<STDEXEC::get_completion_signatures<_Sender, _Env...>()>;
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////
   // __get_child_completion_signatures