passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/move/detail/move_helpers.hpp

@@ -69,13 +69,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(TYPE &x)\
       {  return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -83,12 +83,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -100,12 +100,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -116,14 +116,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      inline typename ::boost::move_detail::enable_if_c\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c\
                         < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
                         , RETURN_VALUE >::type\
       PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
@@ -136,10 +136,10 @@
 #else    //BOOST_NO_CXX11_RVALUE_REFERENCES
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(x); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
    //
 
@@ -174,13 +174,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
       {  return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -188,12 +188,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -205,12 +205,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         inline typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -222,14 +222,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      inline typename ::boost::move_detail::disable_if_or\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::disable_if_or\
                         < RETURN_VALUE \
                         , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
                         , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
@@ -244,10 +244,10 @@
 #else
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
    //
 

data/src/cxx_supportlib/vendor-modified/boost/move/detail/nsec_clock.hpp

@@ -115,7 +115,7 @@ struct QPFHolder
 template<int Dummy>
 const double QPFHolder<Dummy>::nanosecs_per_tic = get_nsec_per_tic();
 
-inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+BOOST_MOVE_FORCEINLINE boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    double nanosecs_per_tic = QPFHolder<0>::nanosecs_per_tic;
    
@@ -132,7 +132,9 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 
 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
 
-inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+namespace boost { namespace move_detail {
+
+BOOST_MOVE_FORCEINLINE boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    boost::uint64_t count = ::mach_absolute_time();
 
@@ -142,6 +144,8 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
       ( static_cast<double>(count)*(static_cast<double>(info.numer) / info.denom) );
 }
 
+}}  //namespace boost { namespace move_detail {
+
 #elif defined(BOOST_MOVE_DETAIL_POSIX_API)
 
 #include <time.h>
@@ -158,7 +162,9 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 #     error "No high resolution steady clock in your system, please provide a patch"
 #  endif
 
-inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
+namespace boost { namespace move_detail {
+
+BOOST_MOVE_FORCEINLINE boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    struct timespec count;
    ::clock_gettime(BOOST_MOVE_DETAIL_CLOCK_MONOTONIC, &count);
@@ -168,6 +174,8 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
    return r;
 }
 
+}}  //namespace boost { namespace move_detail {
+
 #endif  // POSIX
 
 namespace boost { namespace move_detail {
@@ -198,7 +206,7 @@ class cpu_timer
    public:
 
       //  constructor
-      cpu_timer() BOOST_NOEXCEPT                                   { start(); }
+      cpu_timer() BOOST_NOEXCEPT : m_is_stopped(true) {}
 
       //  observers
       bool          is_stopped() const BOOST_NOEXCEPT              { return m_is_stopped; }

data/src/cxx_supportlib/vendor-modified/boost/move/detail/type_traits.hpp

@@ -1352,6 +1352,82 @@ struct aligned_storage
 }  //namespace move_detail {
 }  //namespace boost {
 
+
+#include <boost/move/detail/std_ns_begin.hpp>
+BOOST_MOVE_STD_NS_BEG
+
+template<class T1, class T2>
+struct pair;
+
+BOOST_MOVE_STD_NS_END
+#include <boost/move/detail/std_ns_end.hpp>
+
+namespace boost {
+namespace move_detail {
+
+template<class A, class B>
+struct is_trivially_copy_assignable<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_copy_assignable<A>::value &&
+                                       boost::move_detail::is_trivially_copy_assignable<B>::value;
+};
+
+template<class A, class B>
+struct is_trivially_move_assignable<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_move_assignable<A>::value &&
+                                       boost::move_detail::is_trivially_move_assignable<B>::value;
+};
+
+template<class A, class B>
+struct is_trivially_copy_constructible<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_copy_constructible<A>::value &&
+                                       boost::move_detail::is_trivially_copy_constructible<B>::value;
+};
+
+template<class A, class B>
+struct is_trivially_move_constructible<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_move_constructible<A>::value &&
+                                       boost::move_detail::is_trivially_move_constructible<B>::value;
+};
+
+template<class A, class B>
+struct is_trivially_destructible<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_destructible<A>::value &&
+                                       boost::move_detail::is_trivially_destructible<B>::value;
+};
+
+template <class T1, class T2>
+struct is_class< std::pair<T1, T2> >
+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+{
+   BOOST_STATIC_CONSTEXPR bool value = true;
+};
+
+template <class T1, class T2>
+struct is_union< std::pair<T1, T2> >
+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+{
+   BOOST_STATIC_CONSTEXPR bool value = false;
+};
+
+template <class T1, class T2>
+struct is_class_or_union< std::pair<T1, T2> >
+//This specialization is needed to avoid instantiation of pair in
+//is_class, and allow recursive maps.
+{
+   BOOST_STATIC_CONSTEXPR bool value = true;
+};
+
+}  //namespace move_detail {
+}  //namespace boost {
+
+
 #include <boost/move/detail/config_end.hpp>
 
 #endif   //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/detail/workaround.hpp

@@ -61,7 +61,7 @@
 #elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
    //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_MOVE_FORCEINLINE inline
-#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
+#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
    //Older GCCs have problems with forceinline
    //Clang can have code bloat issues with forceinline, see
    //https://lists.boost.org/boost-users/2023/04/91445.php and

data/src/cxx_supportlib/vendor-modified/boost/move/traits.hpp

@@ -57,6 +57,17 @@ struct has_nothrow_move
                              boost::move_detail::is_nothrow_move_assignable<T>::value;
 };
 
+#ifndef BOOST_MOVE_DOXYGEN_INVOKED
+
+template<class A, class B>
+struct has_trivial_destructor_after_move<std::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::has_trivial_destructor_after_move<A>::value &&
+                                       boost::has_trivial_destructor_after_move<B>::value;
+};
+
+#endif
+
 namespace move_detail {
 
 template <class T>

data/src/cxx_supportlib/vendor-modified/boost/mp11/algorithm.hpp

@@ -153,13 +153,13 @@ template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn
 namespace detail
 {
 
+template<class V, class T> using mp_transform_impl_f = mp_transform<mp_push_back, V, T>;
+
 template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
 {
     using A1 = L1<mp_list<T1, T2, T3, T4>...>;
 
-    template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;
-
-    using A2 = mp_fold<mp_list<L...>, A1, _f>;
+    using A2 = mp_fold<mp_list<L...>, A1, mp_transform_impl_f>;
 
     template<class T> using _g = mp_apply<F, T>;
 
@@ -172,7 +172,7 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 namespace detail
 {
 
-template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+template<template<class...> class P, template<class...> class F> struct mp_transform_if_impl_f
 {
     // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"
 
@@ -181,16 +181,19 @@ template<template<class...> class P, template<class...> class F, class... L> str
 
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
 
-    template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
-    template<class... U> using _f = typename _f_<U...>::type;
+    template<class... U> struct _f { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
+    template<class... U> using fn = typename _f<U...>::type;
 
 #else
 
-    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
+    template<class... U> using fn = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
 
 #endif
+};
 
-    using type = mp_transform<_f, L...>;
+template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+{
+    using type = mp_transform_q<mp_transform_if_impl_f<P, F>, L...>;
 };
 
 } // namespace detail
@@ -202,13 +205,16 @@ template<class Qp, class Qf, class... L> using mp_transform_if_q = typename deta
 namespace detail
 {
 
-template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+template<template<class...> class P> struct mp_filter_impl_f
 {
     using Qp = mp_quote<P>;
 
-    template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+    template<class T1, class... T> using fn = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+};
 
-    using _t1 = mp_transform<_f, L1, L...>;
+template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+{
+    using _t1 = mp_transform_q<mp_filter_impl_f<P>, L1, L...>;
     using _t2 = mp_apply<mp_append, _t1>;
 
     using type = mp_assign<L1, _t2>;
@@ -228,6 +234,8 @@ template<class L, class V> struct mp_fill_impl
 // An error "no type named 'type'" here means that the L argument of mp_fill is not a list
 };
 
+template<class T, class U> using mp_fill_impl_f = T;
+
 template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
 {
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
@@ -237,8 +245,7 @@ template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<
 
 #else
 
-    template<class...> using _f = V;
-    using type = L<_f<T>...>;
+    using type = L< mp_fill_impl_f<V, T>... >;
 
 #endif
 };
@@ -329,11 +336,14 @@ namespace detail
 
 template<class L, class L2, class En> struct mp_drop_impl;
 
-template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
+template<template<class...> class L, class... U> struct mp_drop_impl_f
 {
     template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
+};
 
-    using R = decltype( f( static_cast<mp_identity<T>*>(0) ... ) );
+template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
+{
+    using R = decltype( mp_drop_impl_f<L, U...>::f( static_cast<mp_identity<T>*>(0) ... ) );
 
     using type = typename R::type;
 };
@@ -524,8 +534,7 @@ template<template<class...> class L, class... T, class V, class W> struct mp_rep
     template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
     using type = L<typename _f<T>::type...>;
 #else
-    template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
-    using type = L<_f<T>...>;
+    using type = L<mp_if<std::is_same<T, V>, W, T>...>;
 #endif
 };
 
@@ -545,8 +554,7 @@ template<template<class...> class L, class... T, template<class...> class P, cla
     template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
     using type = L<typename _f<T>::type...>;
 #else
-    template<class U> using _f = mp_if<P<U>, W, U>;
-    using type = L<_f<T>...>;
+    using type = L<mp_if<P<T>, W, T>...>;
 #endif
 };
 
@@ -570,8 +578,7 @@ template<template<class...> class L, class... T, class V> struct mp_remove_impl<
     template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
     using type = mp_append<L<>, typename _f<T>::type...>;
 #else
-    template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
-    using type = mp_append<L<>, _f<T>...>;
+    using type = mp_append<L<>, mp_if<std::is_same<T, V>, mp_list<>, mp_list<T>>...>;
 #endif
 };
 
@@ -639,11 +646,14 @@ template<template<class...> class L, class T1, template<class...> class P> struc
     using type = L<T1>;
 };
 
-template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+template<class T1, template<class...> class P> struct mp_sort_impl_f
 {
-    template<class U> using F = P<U, T1>;
+    template<class U> using fn = P<U, T1>;
+};
 
-    using part = mp_partition<L<T...>, F>;
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+{
+    using part = mp_partition_q<L<T...>, mp_sort_impl_f<T1, P>>;
 
     using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
     using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
@@ -672,9 +682,7 @@ template<template<class...> class L, class T1, class... T, std::size_t I, templa
 {
     static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );
 
-    template<class U> using F = P<U, T1>;
-
-    using part = mp_partition<L<T...>, F>;
+    using part = mp_partition_q<L<T...>, mp_sort_impl_f<T1, P>>;
 
     using L1 = mp_first<part>;
     static std::size_t const N1 = mp_size<L1>::value;
@@ -1030,14 +1038,21 @@ template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;
 namespace detail
 {
 
+template<class I> struct mp_replace_at_impl_p
+{
+    template<class T1, class T2> using fn = std::is_same<T2, I>;
+};
+
+template<class W> struct mp_replace_at_impl_f
+{
+    template<class T1, class T2> using fn = W;
+};
+
 template<class L, class I, class W> struct mp_replace_at_impl
 {
     static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
 
-    template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
-    template<class T1, class T2> using _f = W;
-
-    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
+    using type = mp_transform_if_q<mp_replace_at_impl_p<mp_size_t<I::value>>, mp_replace_at_impl_f<W>, L, mp_iota<mp_size<L> > >;
 };
 
 } // namespace detail
@@ -1182,13 +1197,16 @@ template<template<class...> class L> struct mp_power_set_impl< L<> >
 
 #endif
 
+template<class T1> struct mp_power_set_impl_f
+{
+    template<class L2> using fn = mp_push_front<L2, T1>;
+};
+
 template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
 {
     using S1 = mp_power_set< L<T...> >;
 
-    template<class L2> using _f = mp_push_front<L2, T1>;
-
-    using S2 = mp_transform<_f, S1>;
+    using S2 = mp_transform_q<mp_power_set_impl_f<T1>, S1>;
 
     using type = mp_append< S1, S2 >;
 };
@@ -1260,15 +1278,18 @@ template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwi
 namespace detail
 {
 
+template<class L, std::size_t M> struct mp_sliding_fold_impl_f
+{
+    template<class I> using fn = mp_slice_c<L, I::value, I::value + M>;
+};
+
 template<class C, class L, class Q, class S> struct mp_sliding_fold_impl;
 
 template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_true, L, N, Q>
 {
     static const std::size_t M = mp_size<L>::value - N::value + 1;
 
-    template<class I> using F = mp_slice_c<L, I::value, I::value + M>;
-
-    using J = mp_transform<F, mp_iota<N>>;
+    using J = mp_transform_q<mp_sliding_fold_impl_f<L, M>, mp_iota<N>>;
 
     using type = mp_apply<mp_transform_q, mp_push_front<J, Q>>;
 };

data/src/cxx_supportlib/vendor-modified/boost/mp11/detail/mp_copy_if.hpp

@@ -32,8 +32,7 @@ template<template<class...> class L, class... T, template<class...> class P> str
     template<class U> struct _f { using type = mp_if<P<U>, mp_list<U>, mp_list<>>; };
     using type = mp_append<L<>, typename _f<T>::type...>;
 #else
-    template<class U> using _f = mp_if<P<U>, mp_list<U>, mp_list<>>;
-    using type = mp_append<L<>, _f<T>...>;
+    using type = mp_append<L<>, mp_if<P<T>, mp_list<T>, mp_list<>>...>;
 #endif
 };
 

data/src/cxx_supportlib/vendor-modified/boost/mp11/detail/mp_map_find.hpp

@@ -11,7 +11,8 @@
 #include <boost/mp11/utility.hpp>
 #include <boost/mp11/detail/config.hpp>
 
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+#if (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 140400 )) \
+ || (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 150000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 150200 ))
 
 #include <boost/mp11/detail/mp_list.hpp>
 #include <boost/mp11/detail/mp_append.hpp>
@@ -34,20 +35,24 @@ namespace boost
 namespace mp11
 {
 
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+#if (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 140400 )) \
+ || (BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 150000 ) && BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 150200 ))
 
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120161
 
 namespace detail
 {
 
+template<class K, class T> struct mp_map_find_impl_k
+{
+    using type = mp_if<std::is_same<mp_front<T>, K>, mp_list<T>, mp_list<>>;
+};
+
 template<class M, class K> struct mp_map_find_impl;
 
 template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
 {
-    template<class U> using _f = mp_if<std::is_same<mp_front<U>, K>, mp_list<U>, mp_list<>>;
-
-    using _l = mp_append<_f<T>..., mp_list<void>>;
+    using _l = mp_append<typename mp_map_find_impl_k<K, T>::type..., mp_list<void>>;
 
     using type = mp_front<_l>;
 };
@@ -99,14 +104,17 @@ template<class T> using mpmf_unwrap = typename mpmf_unwrap_impl<T>::type;
 
 template<class M, class K> struct mp_map_find_impl;
 
-template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+template<class K> struct mp_map_find_impl_f
 {
-    using U = mp_inherit<mpmf_wrap<T>...>;
-
     template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
     static mp_identity<void> f( ... );
+};
+
+template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+{
+    using U = mp_inherit<mpmf_wrap<T>...>;
 
-    using type = mpmf_unwrap< decltype( f( static_cast<U*>(0) ) ) >;
+    using type = mpmf_unwrap< decltype( mp_map_find_impl_f<K>::f( static_cast<U*>(0) ) ) >;
 };
 
 } // namespace detail

data/src/cxx_supportlib/vendor-modified/boost/mp11/detail/mp_remove_if.hpp

@@ -32,8 +32,7 @@ template<template<class...> class L, class... T, template<class...> class P> str
     template<class U> struct _f { using type = mp_if<P<U>, mp_list<>, mp_list<U>>; };
     using type = mp_append<L<>, typename _f<T>::type...>;
 #else
-    template<class U> using _f = mp_if<P<U>, mp_list<>, mp_list<U>>;
-    using type = mp_append<L<>, _f<T>...>;
+    using type = mp_append<L<>, mp_if<P<T>, mp_list<>, mp_list<T>>...>;
 #endif
 };
 

data/src/cxx_supportlib/vendor-modified/boost/mp11/integer_sequence.hpp

@@ -19,6 +19,8 @@
 #if defined(__has_builtin)
 # if __has_builtin(__make_integer_seq)
 #  define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
+# elif __has_builtin(__integer_pack)
+#  define BOOST_MP11_HAS_INTEGER_PACK
 # endif
 #endif
 
@@ -36,6 +38,10 @@ template<class T, T... I> struct integer_sequence
 
 template<class T, T N> using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
 
+#elif defined(BOOST_MP11_HAS_INTEGER_PACK)
+
+template<class T, T N> using make_integer_sequence = integer_sequence<T, __integer_pack(N)...>;
+
 #else
 
 // detail::make_integer_sequence_impl

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 109000
+#define BOOST_MP11_VERSION 109200
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED