change __connect_awaitable to await the awaitable with no dynamic allocations

Author: ericniebler

examples/hello_coro.cpp

@@ -19,26 +19,25 @@
 #include <stdexec/execution.hpp>
 
 #if !STDEXEC_NO_STDCPP_COROUTINES() && !STDEXEC_NVHPC()
-#  include <exec/task.hpp>
 
 using namespace stdexec;
 
 template <sender S1, sender S2>
-auto async_answer(S1 s1, S2 s2) -> exec::task<int>
+auto async_answer(S1 s1, S2 s2) -> stdexec::task<int>
 {
   // Senders are implicitly awaitable (in this coroutine type):
   co_await static_cast<S2&&>(s2);
   co_return co_await static_cast<S1&&>(s1);
 }
 
 template <sender S1, sender S2>
-auto async_answer2(S1 s1, S2 s2) -> exec::task<std::optional<int>>
+auto async_answer2(S1 s1, S2 s2) -> stdexec::task<std::optional<int>>
 {
   co_return co_await stopped_as_optional(async_answer(s1, s2));
 }
 
 // tasks have an associated stop token
-auto async_stop_token() -> exec::task<std::optional<stdexec::inplace_stop_token>>
+auto async_stop_token() -> stdexec::task<std::optional<stdexec::inplace_stop_token>>
 {
   co_return co_await stopped_as_optional(get_stop_token());
 }

include/stdexec/__detail/__awaitable.hpp

@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include "../functional.hpp"
 #include "__concepts.hpp"
 #include "__config.hpp"
 #include "__meta.hpp"
@@ -39,20 +40,20 @@ namespace STDEXEC
     __promise.await_transform(static_cast<_Awaitable &&>(__awaitable));
   };
 
-  template <class _Awaitable>
-  constexpr auto __get_awaitable(_Awaitable &&__awaitable, __ignore = {}) -> decltype(auto)
-  {
-    return static_cast<_Awaitable &&>(__awaitable);
-  }
+  inline constexpr auto __get_awaitable = __first_callable{
+    []<class _Promise, __has_await_transform<_Promise> _Awaitable>(_Awaitable &&__awaitable,
+                                                                   _Promise    &__promise)
+      -> decltype(auto)
+    { return __promise.await_transform(static_cast<_Awaitable &&>(__awaitable)); },
+    []<class _Awaitable>(_Awaitable &&__awaitable, __ignore = {}) -> decltype(auto)
+    { return static_cast<_Awaitable &&>(__awaitable); }};
 
-  template <class _Promise, __has_await_transform<_Promise> _Awaitable>
-  constexpr auto __get_awaitable(_Awaitable &&__awaitable, _Promise &__promise) -> decltype(auto)
-  {
-    return __promise.await_transform(static_cast<_Awaitable &&>(__awaitable));
-  }
+  template <class _Awaitable, class _Promise>
+  using __awaitable_of_t = decltype(STDEXEC::__get_awaitable(__declval<_Awaitable>(),
+                                                             __declval<_Promise &>()));
 
-  template <class _Awaitable>
-  constexpr auto __get_awaiter(_Awaitable &&__awaitable) -> decltype(auto)
+  inline constexpr auto __get_awaiter =
+    []<class _Awaitable>(_Awaitable &&__awaitable) -> decltype(auto)
   {
     if constexpr (requires { __declval<_Awaitable>().operator co_await(); })
     {
@@ -66,7 +67,10 @@ namespace STDEXEC
     {
       return static_cast<_Awaitable &&>(__awaitable);
     }
-  }
+  };
+
+  template <class _Awaitable>
+  using __awaiter_of_t = decltype(STDEXEC::__get_awaiter(__declval<_Awaitable>()));
 
   template <class _Awaitable, class... _Promise>
   concept __awaitable = requires(_Awaitable &&__awaitable, _Promise &...__promise) {

include/stdexec/__detail/__config.hpp

@@ -401,6 +401,15 @@ namespace STDEXEC::__std
 #  define STDEXEC_PRAGMA_IGNORE_MSVC(...)
 #endif
 
+#if STDEXEC_MSVC()
+#  define STDEXEC_PRAGMA_OPTIMIZE_BEGIN()  STDEXEC_PRAGMA(optimize("", on))
+#  define STDEXEC_PRAGMA_OPTIMIZE_END()    STDEXEC_PRAGMA(optimize("", off))
+#else
+#  define STDEXEC_PRAGMA_OPTIMIZE_BEGIN()  STDEXEC_PRAGMA(GCC push_options) \
+                                           STDEXEC_PRAGMA(GCC optimize("O3"))
+#  define STDEXEC_PRAGMA_OPTIMIZE_END()    STDEXEC_PRAGMA(GCC pop_options)
+#endif
+
 #if !STDEXEC_MSVC() && defined(__has_builtin)
 #  define STDEXEC_HAS_BUILTIN __has_builtin
 #else