eliminate name conflicts when STDEXEC_NAMESPACE is std::execution

Author: ericniebler

.clang-format

@@ -9,7 +9,7 @@ AlignConsecutiveDeclarations: None
 AlignConsecutiveMacros:
   Enabled: true
   AcrossEmptyLines: true
-  AcrossComments: true
+  AcrossComments: false
 AlignEscapedNewlines: Right
 AlignOperands: AlignAfterOperator
 AlignTrailingComments: true

include/exec/__detail/__basic_sequence.hpp

@@ -57,7 +57,7 @@ namespace exec {
             static_cast<_Child&&>(__child)...)) {
     }
 
-    template <STDEXEC::same_as<__seqexpr> _Self = __seqexpr>
+    template <STDEXEC::__std::same_as<__seqexpr> _Self = __seqexpr>
     auto get_env() const noexcept -> decltype(_Self::__tag().get_env(*this)) {
       static_assert(noexcept(_Self::__tag().get_env(*this)));
       return _Self::__tag().get_env(*this);

include/exec/async_scope.hpp

@@ -338,7 +338,7 @@ namespace exec {
             } else {
               std::visit(
                 [this, &__guard]<class _Tup>(_Tup& __tup) {
-                  if constexpr (same_as<_Tup, std::monostate>) {
+                  if constexpr (__std::same_as<_Tup, std::monostate>) {
                     std::terminate();
                   } else {
                     std::apply(
@@ -465,13 +465,13 @@ namespace exec {
       }
 
       template <class _Uy>
-        requires convertible_to<_Uy*, _Ty*>
+        requires __std::convertible_to<_Uy*, _Ty*>
       __dynamic_delete(std::default_delete<_Uy>)
         : __delete_([](_Ty* __p) { delete static_cast<_Uy*>(__p); }) {
       }
 
       template <class _Uy>
-        requires convertible_to<_Uy*, _Ty*>
+        requires __std::convertible_to<_Uy*, _Ty*>
       auto operator=(std::default_delete<_Uy> __d) -> __dynamic_delete& {
         __delete_ = __dynamic_delete{__d}.__delete_;
         return *this;

include/exec/at_coroutine_exit.hpp

@@ -121,7 +121,7 @@ namespace exec {
 
     template <class _Promise>
     concept __has_continuation = requires(_Promise& __promise, __coroutine_handle<> __c) {
-      { __promise.continuation() } -> convertible_to<__coroutine_handle<>>;
+      { __promise.continuation() } -> __std::convertible_to<__coroutine_handle<>>;
       { __promise.set_continuation(__c) };
     };
 

include/exec/create.hpp

@@ -39,7 +39,7 @@ namespace exec {
     struct __operation {
       using _Context = __context<STDEXEC::__t<_ReceiverId>, STDEXEC::__t<_ArgsId>>;
       using _Result = __call_result_t<_Fun, _Context&>;
-      using _State = __if_c<same_as<_Result, void>, __void, std::optional<_Result>>;
+      using _State = __if_c<__std::same_as<_Result, void>, __void, std::optional<_Result>>;
 
       struct __t : STDEXEC::__immovable {
         using __id = __operation;
@@ -69,8 +69,8 @@ namespace exec {
 
         template <__decays_to<__t> _Self, receiver_of<completion_signatures> _Receiver>
           requires __callable<_Fun, __context<_Receiver, _Args>&>
-                && constructible_from<_Fun, __copy_cvref_t<_Self, _Fun>>
-                && constructible_from<_Args, __copy_cvref_t<_Self, _Args>>
+                && __std::constructible_from<_Fun, __copy_cvref_t<_Self, _Fun>>
+                && __std::constructible_from<_Args, __copy_cvref_t<_Self, _Args>>
         STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this _Self&& __self, _Receiver __rcvr)
           -> STDEXEC::__t<__operation<STDEXEC::__id<_Receiver>, _Fun, _ArgsId>> {
           static_assert(__nothrow_callable<_Fun, __context<_Receiver, _Args>&>);
@@ -87,8 +87,8 @@ namespace exec {
     template <__completion_signature... _Sigs>
     struct __create_t {
       template <class _Fun, class... _Args>
-        requires move_constructible<_Fun>
-              && constructible_from<__decayed_std_tuple<_Args...>, _Args...>
+        requires __std::move_constructible<_Fun>
+              && __std::constructible_from<__decayed_std_tuple<_Args...>, _Args...>
       auto operator()(_Fun __fun, _Args&&... __args) const
         -> __t<__sender<_Fun, __id<__decayed_std_tuple<_Args...>>, _Sigs...>> {
         return {static_cast<_Fun&&>(__fun), {static_cast<_Args&&>(__args)...}};

include/exec/finally.hpp

@@ -216,7 +216,10 @@ namespace exec {
       using __id = __operation_state;
 
       template <class... _Args>
-        requires constructible_from<__result_variant<__signatures>, __decayed_std_tuple<_Args...>>
+        requires __std::constructible_from<
+          __result_variant<__signatures>,
+          __decayed_std_tuple<_Args...>
+        >
       void __store_result_and_start_next_op(_Args&&... __args) {
         this->__result_.__construct(
           std::in_place_type<__decayed_std_tuple<_Args...>>, static_cast<_Args&&>(__args)...);

include/exec/into_tuple.hpp

@@ -79,7 +79,7 @@ namespace exec {
           _Receiver &__rcvr,
           _Tag,
           _Args &&...__args) noexcept -> void {
-        if constexpr (same_as<_Tag, set_value_t>) {
+        if constexpr (__std::same_as<_Tag, set_value_t>) {
           using __tuple_t = __t<_State>;
           STDEXEC_TRY {
             set_value(

include/exec/linux/io_uring_context.hpp

@@ -695,15 +695,15 @@ namespace exec {
       static constexpr __task_vtable __vtable{&__ready_, &__submit_, &__complete_};
 
       template <class... _Args>
-        requires STDEXEC::constructible_from<_Base, std::in_place_t, __task*, _Args...>
+        requires STDEXEC::__std::constructible_from<_Base, std::in_place_t, __task*, _Args...>
       __io_task_facade(std::in_place_t, _Args&&... __args)
         noexcept(STDEXEC::__nothrow_constructible_from<_Base, __task*, _Args...>)
         : __task{__vtable}
         , __base_(std::in_place, static_cast<__task*>(this), static_cast<_Args&&>(__args)...) {
       }
 
       template <class... _Args>
-        requires STDEXEC::constructible_from<_Base, _Args...>
+        requires STDEXEC::__std::constructible_from<_Base, _Args...>
       __io_task_facade(std::in_place_t, _Args&&... __args)
         noexcept(STDEXEC::__nothrow_constructible_from<_Base, _Args...>)
         : __task{__vtable}
@@ -889,7 +889,7 @@ namespace exec {
         __on_receiver_stop_t __on_receiver_stop_{};
 
         template <class... _Args>
-          requires STDEXEC::constructible_from<_Base, _Args...>
+          requires STDEXEC::__std::constructible_from<_Base, _Args...>
         __impl(std::in_place_t, __task* __parent, _Args&&... __args)
           noexcept(STDEXEC::__nothrow_constructible_from<_Base, _Args...>)
           : __base_t(__parent, std::in_place, static_cast<_Args&&>(__args)...)

include/exec/on_coro_disposition.hpp

@@ -39,7 +39,7 @@ namespace exec {
                                       && requires(_Promise& __promise) {
                                            {
                                              __promise.disposition()
-                                           } -> convertible_to<task_disposition>;
+                                           } -> __std::convertible_to<task_disposition>;
                                          };
 
     struct __get_disposition {

include/exec/repeat_effect_until.hpp

@@ -120,7 +120,7 @@ namespace exec {
 
       template <class _Tag, class... _Args>
       void __complete(_Tag, _Args &&...__args) noexcept {
-        if constexpr (same_as<_Tag, set_value_t>) {
+        if constexpr (__std::same_as<_Tag, set_value_t>) {
           // If the sender completed with true, we're done
           STDEXEC_TRY {
             if constexpr ((__compile_time_bool_of<_Args, true> && ...)) {
@@ -170,7 +170,7 @@ namespace exec {
     using __values_t =
       // There's something funny going on with __if_c here. Use std::conditional_t instead. :-(
       std::conditional_t<
-        ((sizeof...(_Args) == 1) && (convertible_to<_Args, bool> && ...)),
+        ((sizeof...(_Args) == 1) && (__std::convertible_to<_Args, bool> && ...)),
         std::conditional_t<
           (__compile_time_bool_of<_Args, false> && ...),
           completion_signatures<>,