From 3fb802f5d03087c19c37b51553e70c7f7f4e88bc Mon Sep 17 00:00:00 2001 From: Carlos Miguel Ferreira Date: Sun, 3 May 2020 20:24:20 +0100 Subject: [PATCH] boost: Package Version Update (1.73.0) This commit updates Boost to version 1.73.0 In this release, there are two new libraries - Nowide [2] - Standard library functions with UTF-8 API on Windows, from Artyom Beilis. - Static String [3] - A dynamically resizable string of characters with compile-time fixed capacity and contiguous embedded storage, from Vinnie Falco and Krystian Stasiowski. More info about Boost 1.73.0 can be found at the usual place [1]. [1]: https://www.boost.org/users/history/version_1_73_0.html [2]: https://www.boost.org/libs/nowide/ [3]: https://www.boost.org/libs/static_string/ Signed-off-by: Carlos Miguel Ferreira --- libs/boost/Makefile | 8 +- libs/boost/patches/002-mips-pause.patch | 28 - libs/boost/patches/002-outcome-assert.patch | 11 + libs/boost/patches/003-beast-coroutines.patch | 1465 +++++++++++++++++ ...003-revert-cease-dependence-on-range.patch | 49 - libs/boost/patches/004-math.patch | 30 - libs/boost/patches/005-math.patch | 17 - 7 files changed, 1480 insertions(+), 128 deletions(-) delete mode 100644 libs/boost/patches/002-mips-pause.patch create mode 100644 libs/boost/patches/002-outcome-assert.patch create mode 100644 libs/boost/patches/003-beast-coroutines.patch delete mode 100644 libs/boost/patches/003-revert-cease-dependence-on-range.patch delete mode 100644 libs/boost/patches/004-math.patch delete mode 100644 libs/boost/patches/005-math.patch diff --git a/libs/boost/Makefile b/libs/boost/Makefile index 042b9f1397..5c188bf152 100644 --- a/libs/boost/Makefile +++ b/libs/boost/Makefile @@ -11,13 +11,13 @@ include $(TOPDIR)/rules.mk PKG_NAME:=boost -PKG_VERSION:=1.72.0 -PKG_SOURCE_VERSION:=1_72_0 +PKG_VERSION:=1.73.0 +PKG_SOURCE_VERSION:=1_73_0 PKG_RELEASE:=1 PKG_SOURCE:=$(PKG_NAME)_$(PKG_SOURCE_VERSION).tar.bz2 PKG_SOURCE_URL:=@SF/$(PKG_NAME)/$(PKG_NAME)/$(PKG_VERSION) https://dl.bintray.com/boostorg/release/$(PKG_VERSION)/source/ -PKG_HASH:=59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417cc660722 +PKG_HASH:=4eb3b8d442b426dc35346235c8733b5ae35ba431690e38c6a8263dce9fcbb402 PKG_MAINTAINER:=Carlos M. Ferreira PKG_LICENSE:=BSL-1.0 @@ -43,7 +43,7 @@ define Package/boost/Default endef define Package/boost/description -This package provides the Boost v1.72.0 libraries. +This package provides the Boost v1.73.0 libraries. Boost is a set of free, peer-reviewed, portable C++ source libraries. This package provides the following run-time libraries: diff --git a/libs/boost/patches/002-mips-pause.patch b/libs/boost/patches/002-mips-pause.patch deleted file mode 100644 index 10a0ae900c..0000000000 --- a/libs/boost/patches/002-mips-pause.patch +++ /dev/null @@ -1,28 +0,0 @@ -From 5f7cda29add367c5381775a314ec9f90e311457a Mon Sep 17 00:00:00 2001 -From: Rosen Penev -Date: Fri, 15 Nov 2019 12:43:50 -0800 -Subject: [PATCH] cpu_relax: Fix MIPS check - -BOOST_ARCH_MIPS as a macro is totally broken. It always gets defined to either 32 -or 64 with a bunch of zeroes depending on the architecture. - -Use GCC's internal define to check the architecture properly. - -Signed-off-by: Rosen Penev ---- - boost/fiber/detail/cpu_relax.hpp | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/boost/fiber/detail/cpu_relax.hpp b/boost/fiber/detail/cpu_relax.hpp -index 72564394..f40545c2 100644 ---- a/boost/fiber/detail/cpu_relax.hpp -+++ b/boost/fiber/detail/cpu_relax.hpp -@@ -47,7 +47,7 @@ namespace detail { - # else - # define cpu_relax() asm volatile ("nop" ::: "memory"); - # endif --#elif BOOST_ARCH_MIPS -+#elif BOOST_ARCH_MIPS && (__mips_isa_rev > 1) - # define cpu_relax() asm volatile ("pause" ::: "memory"); - #elif BOOST_ARCH_PPC - // http://code.metager.de/source/xref/gnu/glibc/sysdeps/powerpc/sys/platform/ppc.h diff --git a/libs/boost/patches/002-outcome-assert.patch b/libs/boost/patches/002-outcome-assert.patch new file mode 100644 index 0000000000..aa996fd668 --- /dev/null +++ b/libs/boost/patches/002-outcome-assert.patch @@ -0,0 +1,11 @@ +--- a/boost/outcome/experimental/status-code/status_code_ptr.hpp 2020-04-28 09:23:14.792565200 +0100 ++++ b/boost/outcome/experimental/status-code/status_code_ptr.hpp 2020-04-28 09:24:34.311741000 +0100 +@@ -103,7 +103,7 @@ + #endif + virtual void _do_erased_copy(status_code &dst, const status_code &src, size_t /*unused*/) const override // NOLINT + { +- assert(dst.domain() == *this); ++ // Note that dst will not have its domain set + assert(src.domain() == *this); + auto &d = static_cast<_mycode &>(dst); // NOLINT + const auto &_s = static_cast(src); // NOLINT diff --git a/libs/boost/patches/003-beast-coroutines.patch b/libs/boost/patches/003-beast-coroutines.patch new file mode 100644 index 0000000000..58ea503062 --- /dev/null +++ b/libs/boost/patches/003-beast-coroutines.patch @@ -0,0 +1,1465 @@ +--- a/boost/beast/core/detail/impl/read.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/detail/impl/read.hpp 2020-05-02 13:50:11.141761700 -0400 +@@ -214,7 +214,7 @@ + class AsyncReadStream, + class DynamicBuffer, + class CompletionCondition, +- class ReadHandler, ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler, + class> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + async_read( +diff -aruN a/boost/beast/core/detail/is_invocable.hpp b/boost/beast/core/detail/is_invocable.hpp +--- a/boost/beast/core/detail/is_invocable.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/detail/is_invocable.hpp 2020-05-02 13:50:11.141761700 -0400 +@@ -10,6 +10,8 @@ + #ifndef BOOST_BEAST_DETAIL_IS_INVOCABLE_HPP + #define BOOST_BEAST_DETAIL_IS_INVOCABLE_HPP + ++#include ++#include + #include + #include + +@@ -51,6 +53,26 @@ + }; + /** @} */ + ++template ++struct is_completion_token_for : std::false_type ++{ ++}; ++ ++struct any_initiation ++{ ++ template ++ void operator()(AnyArgs&&...); ++}; ++ ++template ++struct is_completion_token_for< ++ CompletionToken, R(Args...), boost::void_t( ++ any_initiation(), std::declval()) ++ )>> : std::true_type ++{ ++}; ++ + } // detail + } // beast + } // boost +diff -aruN a/boost/beast/core/detail/read.hpp b/boost/beast/core/detail/read.hpp +--- a/boost/beast/core/detail/read.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/detail/read.hpp 2020-05-02 13:50:11.142761711 -0400 +@@ -219,7 +219,7 @@ + class AsyncReadStream, + class DynamicBuffer, + class CompletionCondition, +- class ReadHandler ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler + #if ! BOOST_BEAST_DOXYGEN + , class = typename std::enable_if< + is_async_read_stream::value && +diff -aruN a/boost/beast/core/detect_ssl.hpp b/boost/beast/core/detect_ssl.hpp +--- a/boost/beast/core/detect_ssl.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/detect_ssl.hpp 2020-05-02 13:50:11.143761722 -0400 +@@ -374,13 +374,13 @@ + void operator()( + DetectHandler&& h, + AsyncReadStream* s, // references are passed as pointers +- DynamicBuffer& b) ++ DynamicBuffer* b) + { + detect_ssl_op< + typename std::decay::type, + AsyncReadStream, + DynamicBuffer>( +- std::forward(h), *s, b); ++ std::forward(h), *s, *b); + } + }; + +@@ -439,7 +439,7 @@ + detail::run_detect_ssl_op{}, + token, + &stream, // pass the reference by pointer +- buffer); ++ &buffer); + } + + //] +diff -aruN a/boost/beast/core/impl/basic_stream.hpp b/boost/beast/core/impl/basic_stream.hpp +--- a/boost/beast/core/impl/basic_stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/impl/basic_stream.hpp 2020-05-02 13:50:11.144761733 -0400 +@@ -776,7 +776,7 @@ + //------------------------------------------------------------------------------ + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(ConnectHandler) + basic_stream:: + async_connect( +@@ -795,7 +795,7 @@ + template + template< + class EndpointSequence, +- class RangeConnectHandler, ++ BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, typename Protocol::endpoint)) RangeConnectHandler, + class> + BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,void(error_code, typename Protocol::endpoint)) + basic_stream:: +@@ -817,7 +817,7 @@ + template< + class EndpointSequence, + class ConnectCondition, +- class RangeConnectHandler, ++ BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, typename Protocol::endpoint)) RangeConnectHandler, + class> + BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,void (error_code, typename Protocol::endpoint)) + basic_stream:: +@@ -839,7 +839,7 @@ + template + template< + class Iterator, +- class IteratorConnectHandler> ++ BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, Iterator)) IteratorConnectHandler> + BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,void (error_code, Iterator)) + basic_stream:: + async_connect( +@@ -860,7 +860,7 @@ + template< + class Iterator, + class ConnectCondition, +- class IteratorConnectHandler> ++ BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, Iterator)) IteratorConnectHandler> + BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,void (error_code, Iterator)) + basic_stream:: + async_connect( +@@ -881,7 +881,7 @@ + //------------------------------------------------------------------------------ + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + basic_stream:: + async_read_some( +@@ -901,7 +901,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + basic_stream:: + async_write_some( +diff -aruN a/boost/beast/core/impl/buffered_read_stream.hpp b/boost/beast/core/impl/buffered_read_stream.hpp +--- a/boost/beast/core/impl/buffered_read_stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/impl/buffered_read_stream.hpp 2020-05-02 13:50:11.144761733 -0400 +@@ -110,7 +110,7 @@ + operator()( + ReadHandler&& h, + buffered_read_stream* s, +- Buffers const& b) ++ Buffers const* b) + { + // If you get an error on the following line it means + // that your handler does not meet the documented type +@@ -124,7 +124,7 @@ + read_op< + Buffers, + typename std::decay::type>( +- std::forward(h), *s, b); ++ std::forward(h), *s, *b); + } + }; + +@@ -141,7 +141,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + buffered_read_stream:: + async_write_some( +@@ -153,7 +153,7 @@ + static_assert(net::is_const_buffer_sequence< + ConstBufferSequence>::value, + "ConstBufferSequence type requirements not met"); +- static_assert(detail::is_invocable::value, + "WriteHandler type requirements not met"); + return next_layer_.async_write_some(buffers, +@@ -212,7 +212,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + buffered_read_stream:: + async_read_some( +@@ -233,7 +233,7 @@ + typename ops::run_read_op{}, + handler, + this, +- buffers); ++ &buffers); + } + + } // beast +diff -aruN a/boost/beast/core/impl/flat_stream.hpp b/boost/beast/core/impl/flat_stream.hpp +--- a/boost/beast/core/impl/flat_stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/core/impl/flat_stream.hpp 2020-05-02 13:50:11.145761743 -0400 +@@ -144,7 +144,7 @@ + template + template< + class MutableBufferSequence, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + flat_stream:: + async_read_some( +@@ -225,7 +225,7 @@ + template + template< + class ConstBufferSequence, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + flat_stream:: + async_write_some( +diff -aruN a/boost/beast/_experimental/http/impl/icy_stream.hpp b/boost/beast/_experimental/http/impl/icy_stream.hpp +--- a/boost/beast/_experimental/http/impl/icy_stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/_experimental/http/impl/icy_stream.hpp 2020-05-02 13:50:11.146761754 -0400 +@@ -259,7 +259,7 @@ + template + template< + class MutableBufferSequence, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + icy_stream:: + async_read_some( +@@ -311,7 +311,7 @@ + template + template< + class MutableBufferSequence, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + icy_stream:: + async_write_some( +diff -aruN a/boost/beast/_experimental/test/impl/stream.hpp b/boost/beast/_experimental/test/impl/stream.hpp +--- a/boost/beast/_experimental/test/impl/stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/_experimental/test/impl/stream.hpp 2020-05-02 13:50:11.147761765 -0400 +@@ -306,7 +306,7 @@ + return 0; + } + +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + stream:: + async_read_some( +@@ -386,7 +386,7 @@ + return n; + } + +-template ++template + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + stream:: + async_write_some( +diff -aruN a/boost/beast/http/field.hpp b/boost/beast/http/field.hpp +--- a/boost/beast/http/field.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/field.hpp 2020-05-02 13:50:11.149761786 -0400 +@@ -396,12 +396,9 @@ + string_to_field(string_view s); + + /// Write the text for a field name to an output stream. +-inline ++BOOST_BEAST_DECL + std::ostream& +-operator<<(std::ostream& os, field f) +-{ +- return os << to_string(f); +-} ++operator<<(std::ostream& os, field f); + + } // http + } // beast +diff -aruN a/boost/beast/http/impl/field.ipp b/boost/beast/http/impl/field.ipp +--- a/boost/beast/http/impl/field.ipp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/impl/field.ipp 2020-05-02 13:50:11.150761798 -0400 +@@ -11,10 +11,12 @@ + #define BOOST_BEAST_HTTP_IMPL_FIELD_IPP + + #include ++#include + #include + #include + #include +-#include ++#include ++ + + namespace boost { + namespace beast { +@@ -565,6 +567,12 @@ + return detail::get_field_table().string_to_field(s); + } + ++std::ostream& ++operator<<(std::ostream& os, field f) ++{ ++ return os << to_string(f); ++} ++ + } // http + } // beast + } // boost +diff -aruN a/boost/beast/http/impl/file_body_win32.hpp b/boost/beast/http/impl/file_body_win32.hpp +--- a/boost/beast/http/impl/file_body_win32.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/impl/file_body_win32.hpp 2020-05-02 13:50:11.150761798 -0400 +@@ -597,7 +597,7 @@ + template< + class Protocol, class Executor, + bool isRequest, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write_some( + net::basic_stream_socket< +diff -aruN a/boost/beast/http/impl/read.hpp b/boost/beast/http/impl/read.hpp +--- a/boost/beast/http/impl/read.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/impl/read.hpp 2020-05-02 13:50:11.150761798 -0400 +@@ -304,7 +304,7 @@ + class AsyncReadStream, + class DynamicBuffer, + bool isRequest, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + async_read_some( + AsyncReadStream& stream, +@@ -373,7 +373,7 @@ + class AsyncReadStream, + class DynamicBuffer, + bool isRequest, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + async_read_header( + AsyncReadStream& stream, +@@ -443,7 +443,7 @@ + class AsyncReadStream, + class DynamicBuffer, + bool isRequest, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + async_read( + AsyncReadStream& stream, +@@ -531,7 +531,7 @@ + class AsyncReadStream, + class DynamicBuffer, + bool isRequest, class Body, class Allocator, +- class ReadHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + async_read( + AsyncReadStream& stream, +diff -aruN a/boost/beast/http/impl/write.hpp b/boost/beast/http/impl/write.hpp +--- a/boost/beast/http/impl/write.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/impl/write.hpp 2020-05-02 13:50:11.150761798 -0400 +@@ -463,7 +463,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write_some_impl( + AsyncWriteStream& stream, +@@ -526,7 +526,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write_some( + AsyncWriteStream& stream, +@@ -608,7 +608,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write_header( + AsyncWriteStream& stream, +@@ -681,7 +681,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write( + AsyncWriteStream& stream, +@@ -801,7 +801,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write( + AsyncWriteStream& stream, +@@ -830,7 +830,7 @@ + template< + class AsyncWriteStream, + bool isRequest, class Body, class Fields, +- class WriteHandler> ++ BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + async_write( + AsyncWriteStream& stream, +diff -aruN a/boost/beast/http/span_body.hpp b/boost/beast/http/span_body.hpp +--- a/boost/beast/http/span_body.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/http/span_body.hpp 2020-05-02 13:50:11.151761808 -0400 +@@ -36,8 +36,10 @@ + struct span_body + { + private: +- static_assert(std::is_pod::value, +- "POD requirements not met"); ++ static_assert( ++ std::is_trivial::value && ++ std::is_standard_layout::value, ++ "POD requirements not met"); + + public: + /** The type of container used for the body +diff -aruN a/boost/beast/ssl/ssl_stream.hpp b/boost/beast/ssl/ssl_stream.hpp +--- a/boost/beast/ssl/ssl_stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/ssl/ssl_stream.hpp 2020-05-02 13:50:11.151761808 -0400 +@@ -555,7 +555,7 @@ + need to ensure that all data is written before the asynchronous operation + completes. + */ +- template ++ template + BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void(boost::system::error_code, std::size_t)) + async_write_some(ConstBufferSequence const& buffers, + BOOST_ASIO_MOVE_ARG(WriteHandler) handler) +@@ -636,7 +636,7 @@ + if you need to ensure that the requested amount of data is read before + the asynchronous operation completes. + */ +- template ++ template + BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, void(boost::system::error_code, std::size_t)) + async_read_some(MutableBufferSequence const& buffers, + BOOST_ASIO_MOVE_ARG(ReadHandler) handler) +diff -aruN a/boost/beast/version.hpp b/boost/beast/version.hpp +--- a/boost/beast/version.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/version.hpp 2020-05-02 13:50:11.151761808 -0400 +@@ -20,7 +20,7 @@ + This is a simple integer that is incremented by one every + time a set of code changes is merged to the develop branch. + */ +-#define BOOST_BEAST_VERSION 290 ++#define BOOST_BEAST_VERSION 292 + + #define BOOST_BEAST_VERSION_STRING "Boost.Beast/" BOOST_STRINGIZE(BOOST_BEAST_VERSION) + +diff -aruN a/boost/beast/websocket/impl/accept.hpp b/boost/beast/websocket/impl/accept.hpp +--- a/boost/beast/websocket/impl/accept.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/accept.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -542,7 +542,7 @@ + + template + template< +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept( +@@ -564,7 +564,7 @@ + template + template< + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept_ex( +@@ -590,7 +590,7 @@ + template + template< + class ConstBufferSequence, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept( +@@ -621,7 +621,7 @@ + template< + class ConstBufferSequence, + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept_ex( +@@ -654,7 +654,7 @@ + template + template< + class Body, class Allocator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept( +@@ -678,7 +678,7 @@ + template< + class Body, class Allocator, + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + stream:: + async_accept_ex( +diff -aruN a/boost/beast/websocket/impl/close.hpp b/boost/beast/websocket/impl/close.hpp +--- a/boost/beast/websocket/impl/close.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/close.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -382,7 +382,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(CloseHandler) + stream:: + async_close(close_reason const& cr, CloseHandler&& handler) +diff -aruN a/boost/beast/websocket/impl/handshake.hpp b/boost/beast/websocket/impl/handshake.hpp +--- a/boost/beast/websocket/impl/handshake.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/handshake.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -268,7 +268,7 @@ + //------------------------------------------------------------------------------ + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) + stream:: + async_handshake( +@@ -293,7 +293,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) + stream:: + async_handshake( +diff -aruN a/boost/beast/websocket/impl/ping.hpp b/boost/beast/websocket/impl/ping.hpp +--- a/boost/beast/websocket/impl/ping.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/ping.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -288,7 +288,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(WriteHandler) + stream:: + async_ping(ping_data const& payload, WriteHandler&& handler) +@@ -306,7 +306,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT1(WriteHandler) + stream:: + async_pong(ping_data const& payload, WriteHandler&& handler) +diff -aruN a/boost/beast/websocket/impl/read.hpp b/boost/beast/websocket/impl/read.hpp +--- a/boost/beast/websocket/impl/read.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/read.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -804,7 +804,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + stream:: + async_read(DynamicBuffer& buffer, ReadHandler&& handler) +@@ -878,7 +878,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + stream:: + async_read_some( +@@ -1263,7 +1263,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(ReadHandler) + stream:: + async_read_some( +diff -aruN a/boost/beast/websocket/impl/write.hpp b/boost/beast/websocket/impl/write.hpp +--- a/boost/beast/websocket/impl/write.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/impl/write.hpp 2020-05-02 13:50:11.153761830 -0400 +@@ -700,7 +700,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + stream:: + async_write_some(bool fin, +@@ -756,7 +756,7 @@ + } + + template +-template ++template + BOOST_BEAST_ASYNC_RESULT2(WriteHandler) + stream:: + async_write( +diff -aruN a/boost/beast/websocket/stream.hpp b/boost/beast/websocket/stream.hpp +--- a/boost/beast/websocket/stream.hpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/boost/beast/websocket/stream.hpp 2020-05-02 13:50:11.154761841 -0400 +@@ -2634,7 +2634,7 @@ + + template< + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + async_accept_ex( + ResponseDecorator const& decorator, +@@ -2643,7 +2643,7 @@ + template< + class ConstBufferSequence, + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + async_accept_ex( + ConstBufferSequence const& buffers, +@@ -2656,7 +2656,7 @@ + template< + class Body, class Allocator, + class ResponseDecorator, +- class AcceptHandler> ++ BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> + BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) + async_accept_ex( + http::request ++ template + typename net::async_result::return_type + async_read(AsyncReadStream& stream, net::mutable_buffer buffer, ReadHandler&& handler) + { +diff -aruN a/libs/beast/test/beast/core/basic_stream.cpp b/libs/beast/test/beast/core/basic_stream.cpp +--- a/libs/beast/test/beast/core/basic_stream.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/core/basic_stream.cpp 2020-05-02 13:51:02.470315892 -0400 +@@ -30,6 +30,13 @@ + #include + #include + ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#include ++#include ++#endif ++ ++ + namespace boost { + namespace beast { + +@@ -258,7 +265,7 @@ + { + string_view s_; + net::ip::tcp::socket socket_; +- ++ + public: + session( + string_view s, +@@ -1297,6 +1304,52 @@ + + //-------------------------------------------------------------------------- + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompilation( ++ basic_stream& stream, ++ net::mutable_buffer outbuf, ++ net::const_buffer inbuf, ++ net::ip::tcp::resolver::results_type resolve_results) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_read_some(outbuf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_write_some(inbuf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_connect( ++ resolve_results.begin(), ++ resolve_results.end(), ++ net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_connect( ++ resolve_results, ++ net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_connect( ++ resolve_results.begin()->endpoint(), ++ net::use_awaitable))>); ++ ++ auto comparison_function = [](error_code&, net::ip::tcp::endpoint) { return true; }; ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_connect( ++ resolve_results.begin(), ++ resolve_results.end(), ++ comparison_function, ++ net::use_awaitable))>); ++ } ++#endif ++ + void + run() + { +@@ -1307,6 +1360,11 @@ + testMembers(); + testJavadocs(); + testIssue1589(); ++ ++#if BOOST_ASIO_HAS_CO_AWAIT ++ // test for compilation success only ++ boost::ignore_unused(&basic_stream_test::testAwaitableCompilation); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/core/buffered_read_stream.cpp b/libs/beast/test/beast/core/buffered_read_stream.cpp +--- a/libs/beast/test/beast/core/buffered_read_stream.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/core/buffered_read_stream.cpp 2020-05-02 13:51:02.470315892 -0400 +@@ -21,6 +21,9 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -211,6 +214,22 @@ + } + }; + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ buffered_read_stream& stream, ++ net::mutable_buffer rxbuf, ++ net::const_buffer txbuf) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_read_some(rxbuf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_write_some(txbuf, net::use_awaitable))>); ++ } ++#endif ++ + void run() override + { + testSpecialMembers(); +@@ -221,6 +240,10 @@ + }); + + testAsyncLoop(); ++ ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&buffered_read_stream_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/core/detect_ssl.cpp b/libs/beast/test/beast/core/detect_ssl.cpp +--- a/libs/beast/test/beast/core/detect_ssl.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/core/detect_ssl.cpp 2020-05-02 13:51:02.470315892 -0400 +@@ -16,6 +16,11 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#include ++#include ++#endif + namespace boost { + namespace beast { + +@@ -166,12 +171,25 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles(test::stream& stream, flat_buffer& b) ++ { ++ static_assert( ++ std::is_same_v< ++ net::awaitable, decltype( ++ async_detect_ssl(stream, b, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { + testDetect(); + testRead(); + testAsyncRead(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&detect_ssl_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/core/flat_stream.cpp b/libs/beast/test/beast/core/flat_stream.cpp +--- a/libs/beast/test/beast/core/flat_stream.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/core/flat_stream.cpp 2020-05-02 13:51:02.471315902 -0400 +@@ -17,6 +17,9 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -208,11 +211,30 @@ + check({1,2,3,4}, 3, 3, true); + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ flat_stream& stream, ++ net::mutable_buffer rxbuf, ++ net::const_buffer txbuf) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_read_some(rxbuf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ stream.async_write_some(txbuf, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { + testMembers(); + testSplit(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&flat_stream_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/core/stream_traits.cpp b/libs/beast/test/beast/core/stream_traits.cpp +--- a/libs/beast/test/beast/core/stream_traits.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/core/stream_traits.cpp 2020-05-02 13:51:02.471315902 -0400 +@@ -214,14 +214,14 @@ + struct async_read_stream + { + net::io_context::executor_type get_executor() noexcept; +- template ++ template + void async_read_some(MutableBufferSequence const&, ReadHandler&&); + }; + + struct async_write_stream + { + net::io_context::executor_type get_executor() noexcept; +- template ++ template + void async_write_some(ConstBufferSequence const&, WriteHandler&&); + }; + +@@ -232,9 +232,9 @@ + struct async_stream : async_read_stream, async_write_stream + { + net::io_context::executor_type get_executor() noexcept; +- template ++ template + void async_read_some(MutableBufferSequence const&, ReadHandler&&); +- template ++ template + void async_write_some(ConstBufferSequence const&, WriteHandler&&); + }; + +diff -aruN a/libs/beast/test/beast/http/CMakeLists.txt b/libs/beast/test/beast/http/CMakeLists.txt +--- a/libs/beast/test/beast/http/CMakeLists.txt 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/http/CMakeLists.txt 2020-05-02 13:51:02.472315914 -0400 +@@ -26,6 +26,7 @@ + empty_body.cpp + error.cpp + field.cpp ++ field_compiles.cpp + fields.cpp + file_body.cpp + message.cpp +diff -aruN a/libs/beast/test/beast/http/field_compiles.cpp b/libs/beast/test/beast/http/field_compiles.cpp +--- a/libs/beast/test/beast/http/field_compiles.cpp 1969-12-31 19:00:00.000000000 -0500 ++++ b/libs/beast/test/beast/http/field_compiles.cpp 2020-05-02 13:51:02.473315924 -0400 +@@ -0,0 +1,11 @@ ++// ++// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) ++// ++// Distributed under the Boost Software License, Version 1.0. (See accompanying ++// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ++// ++// Official repository: https://github.com/boostorg/beast ++// ++ ++// Test that header file is self-contained. ++#include +diff -aruN a/libs/beast/test/beast/http/Jamfile b/libs/beast/test/beast/http/Jamfile +--- a/libs/beast/test/beast/http/Jamfile 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/http/Jamfile 2020-05-02 13:51:02.472315914 -0400 +@@ -16,6 +16,7 @@ + dynamic_body.cpp + error.cpp + field.cpp ++ field_compiles.cpp + fields.cpp + file_body.cpp + message.cpp +diff -aruN a/libs/beast/test/beast/http/read.cpp b/libs/beast/test/beast/http/read.cpp +--- a/libs/beast/test/beast/http/read.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/http/read.cpp 2020-05-02 13:51:02.472315914 -0400 +@@ -25,6 +25,9 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -529,6 +532,49 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ test::stream& stream, ++ flat_buffer& dynbuf, ++ parser& request_parser, ++ request& request, ++ parser& response_parser, ++ response& response) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read(stream, dynbuf, request, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read(stream, dynbuf, request_parser, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read(stream, dynbuf, response, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read(stream, dynbuf, response_parser, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read_some(stream, dynbuf, request_parser, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read_some(stream, dynbuf, response_parser, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read_header(stream, dynbuf, request_parser, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_read_header(stream, dynbuf, response_parser, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { +@@ -552,6 +598,9 @@ + testRegression430(); + testReadGrind(); + testAsioHandlerInvoke(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&read_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/http/write.cpp b/libs/beast/test/beast/http/write.cpp +--- a/libs/beast/test/beast/http/write.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/http/write.cpp 2020-05-02 13:51:02.473315924 -0400 +@@ -26,6 +26,9 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -994,6 +997,59 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ test::stream& stream, ++ serializer& request_serializer, ++ request& req, ++ request const& creq, ++ serializer& response_serializer, ++ response& resp, ++ response const& cresp) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, request_serializer, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, response_serializer, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, req, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, creq, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, resp, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write(stream, cresp, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write_some(stream, request_serializer, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write_some(stream, response_serializer, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write_header(stream, request_serializer, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ http::async_write_header(stream, response_serializer, net::use_awaitable))>); ++ } ++#endif ++ ++ + void + run() override + { +@@ -1017,6 +1073,9 @@ + }); + testAsioHandlerInvoke(); + testBodyWriters(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&write_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/accept.cpp b/libs/beast/test/beast/websocket/accept.cpp +--- a/libs/beast/test/beast/websocket/accept.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/accept.cpp 2020-05-02 13:51:02.473315924 -0400 +@@ -14,7 +14,9 @@ + #include + #include + #include "test.hpp" +- ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + namespace boost { + namespace beast { + namespace websocket { +@@ -810,6 +812,27 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ stream& s, ++ http::request& req, ++ net::mutable_buffer buf ++ ) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_accept(net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_accept(req, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_accept(buf, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { +@@ -820,6 +843,9 @@ + testInvalidInputs(); + testEndOfStream(); + testAsync(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&accept_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/close.cpp b/libs/beast/test/beast/websocket/close.cpp +--- a/libs/beast/test/beast/websocket/close.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/close.cpp 2020-05-02 13:51:02.473315924 -0400 +@@ -16,6 +16,9 @@ + + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -735,6 +738,15 @@ + } + }; + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles(stream& s, close_reason cr ) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_close(cr, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { +@@ -742,6 +754,9 @@ + testTimeout(); + testSuspend(); + testMoveOnly(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&close_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/handshake.cpp b/libs/beast/test/beast/websocket/handshake.cpp +--- a/libs/beast/test/beast/websocket/handshake.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/handshake.cpp 2020-05-02 13:51:02.473315924 -0400 +@@ -18,6 +18,9 @@ + #include + #include + #include ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif + + namespace boost { + namespace beast { +@@ -704,6 +707,23 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ stream& s, ++ std::string host, ++ std::string port, ++ response_type& resp) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_handshake(host, port, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_handshake(resp, host, port, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { +@@ -714,6 +734,9 @@ + testMoveOnly(); + testAsync(); + testIssue1460(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&handshake_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/ping.cpp b/libs/beast/test/beast/websocket/ping.cpp +--- a/libs/beast/test/beast/websocket/ping.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/ping.cpp 2020-05-02 13:51:02.474315935 -0400 +@@ -18,6 +18,10 @@ + #include + #include + ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif ++ + namespace boost { + namespace beast { + namespace websocket { +@@ -483,12 +487,30 @@ + } + }; + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ stream& s, ++ ping_data& pdat) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_ping(pdat, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_pong(pdat, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { + testPing(); + testSuspend(); + testMoveOnly(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&ping_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/read2.cpp b/libs/beast/test/beast/websocket/read2.cpp +--- a/libs/beast/test/beast/websocket/read2.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/read2.cpp 2020-05-02 13:51:02.474315935 -0400 +@@ -14,6 +14,10 @@ + + #include + ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif ++ + #include + #if BOOST_WORKAROUND(BOOST_GCC, < 80200) + #define BOOST_BEAST_SYMBOL_HIDDEN __attribute__ ((visibility("hidden"))) +@@ -673,10 +677,34 @@ + } + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ stream& s, ++ flat_buffer& dynbuf, ++ net::mutable_buffer buf, ++ std::size_t limit) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_read(dynbuf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_read_some(buf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_read_some(dynbuf, limit, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { + testRead(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&read2_test::testAwaitableCompiles); ++#endif + } + }; + +diff -aruN a/libs/beast/test/beast/websocket/write.cpp b/libs/beast/test/beast/websocket/write.cpp +--- a/libs/beast/test/beast/websocket/write.cpp 2020-04-22 09:34:50.000000000 -0400 ++++ b/libs/beast/test/beast/websocket/write.cpp 2020-05-02 13:51:02.474315935 -0400 +@@ -13,6 +13,10 @@ + #include + #include + ++#if BOOST_ASIO_HAS_CO_AWAIT ++#include ++#endif ++ + #include "test.hpp" + + namespace boost { +@@ -716,6 +720,22 @@ + BEAST_EXPECT(n1 < n0 + s.size()); + } + ++#if BOOST_ASIO_HAS_CO_AWAIT ++ void testAwaitableCompiles( ++ stream& s, ++ net::mutable_buffer buf, ++ bool fin) ++ { ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_write(buf, net::use_awaitable))>); ++ ++ static_assert(std::is_same_v< ++ net::awaitable, decltype( ++ s.async_write_some(fin, buf, net::use_awaitable))>); ++ } ++#endif ++ + void + run() override + { +@@ -726,6 +746,9 @@ + testMoveOnly(); + testIssue300(); + testIssue1666(); ++#if BOOST_ASIO_HAS_CO_AWAIT ++ boost::ignore_unused(&write_test::testAwaitableCompiles); ++#endif + } + }; + diff --git a/libs/boost/patches/003-revert-cease-dependence-on-range.patch b/libs/boost/patches/003-revert-cease-dependence-on-range.patch deleted file mode 100644 index a6002074ab..0000000000 --- a/libs/boost/patches/003-revert-cease-dependence-on-range.patch +++ /dev/null @@ -1,49 +0,0 @@ -From 436e1dbe6fcd31523d261d18ad011392f1d6fbbc Mon Sep 17 00:00:00 2001 -From: Oliver Kowalke -Date: Sun, 1 Dec 2019 20:40:28 +0100 -Subject: [PATCH] Revert "Cease dependence on Range" - -This reverts commit 0c556bb59241e682bbcd3f572815149c5a9b17db. - -see #44 (One test fails to compile after boostorg/coroutine submodule updated) ---- - boost/coroutine/asymmetric_coroutine.hpp | 12 +++--------- - 1 file changed, 3 insertions(+), 9 deletions(-) - -diff --git a/boost/coroutine/asymmetric_coroutine.hpp b/boost/coroutine/asymmetric_coroutine.hpp -index ea96981..640896f 100644 ---- a/boost/coroutine/asymmetric_coroutine.hpp -+++ b/boost/coroutine/asymmetric_coroutine.hpp -@@ -14,6 +14,7 @@ - #include - #include - #include -+#include - #include - #include - -@@ -2354,19 +2355,12 @@ end( push_coroutine< R > & c) - - } - --// forward declaration of Boost.Range traits to break dependency on it --template --struct range_mutable_iterator; -- --template --struct range_const_iterator; -- - template< typename Arg > --struct range_mutable_iterator< coroutines::push_coroutine< Arg >, void > -+struct range_mutable_iterator< coroutines::push_coroutine< Arg > > - { typedef typename coroutines::push_coroutine< Arg >::iterator type; }; - - template< typename R > --struct range_mutable_iterator< coroutines::pull_coroutine< R >, void > -+struct range_mutable_iterator< coroutines::pull_coroutine< R > > - { typedef typename coroutines::pull_coroutine< R >::iterator type; }; - - } --- -2.24.1 - diff --git a/libs/boost/patches/004-math.patch b/libs/boost/patches/004-math.patch deleted file mode 100644 index 5230e3306c..0000000000 --- a/libs/boost/patches/004-math.patch +++ /dev/null @@ -1,30 +0,0 @@ -From 5f19fd7dc6c4dd37fb0409f08a0b7dbb887dd516 Mon Sep 17 00:00:00 2001 -From: Rosen Penev -Date: Thu, 19 Dec 2019 17:46:46 -0800 -Subject: [PATCH] roots: Fix fma_workaround - -fma takes three parameters, not one. - -Signed-off-by: Rosen Penev ---- - include/boost/math/tools/roots.hpp | 6 +++--- - 1 file changed, 3 insertions(+), 3 deletions(-) - -diff --git a/boost/math/tools/roots.hpp b/boost/math/tools/roots.hpp -index 8b3ab7eb9..5d7936bb2 100644 ---- a/boost/math/tools/roots.hpp -+++ b/boost/math/tools/roots.hpp -@@ -861,10 +861,10 @@ Complex complex_newton(F g, Complex guess, int max_iterations = std::numeric_lim - namespace detail - { - #if defined(BOOST_GNU_STDLIB) && !defined(_GLIBCXX_USE_C99_MATH_TR1) --float fma_workaround(float f) { return ::fmaf(f); } --double fma_workaround(double f) { return ::fma(f); } -+inline float fma_workaround(float x, float y, float z) { return ::fmaf(x, y, z); } -+inline double fma_workaround(double x, double y, double z) { return ::fma(x, y, z); } - #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS --long double fma_workaround(long double f) { return ::fmal(f); } -+inline long double fma_workaround(long double x, long double y, long double z) { return ::fmal(x, y, z); } - #endif - #endif - template diff --git a/libs/boost/patches/005-math.patch b/libs/boost/patches/005-math.patch deleted file mode 100644 index e656d03305..0000000000 --- a/libs/boost/patches/005-math.patch +++ /dev/null @@ -1,17 +0,0 @@ -Index: boost_1_72_0/boost/math/tools/roots.hpp -=================================================================== ---- boost_1_72_0.orig/boost/math/tools/roots.hpp -+++ boost_1_72_0/boost/math/tools/roots.hpp -@@ -884,7 +884,11 @@ inline T discriminant(T const& a, T cons - template - std::pair quadratic_roots_imp(T const& a, T const& b, T const& c) - { -- using std::copysign; -+ #if defined(BOOST_GNU_STDLIB) && !defined(_GLIBCXX_USE_C99_MATH_TR1) -+ using boost::math::copysign; -+ #else -+ using std::copysign; -+ #endif - using std::sqrt; - if constexpr (std::is_floating_point::value) - {