passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash.hpp

@@ -455,7 +455,11 @@ namespace boost
         std::size_t seed = 0;
 
         hash_combine( seed, v.index() );
-        std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );
+
+        if( !v.valueless_by_exception() )
+        {
+            std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );
+        }
 
         return seed;
     }

data/src/cxx_supportlib/vendor-modified/boost/core/lightweight_test.hpp

@@ -156,18 +156,15 @@ inline void no_throw_failed_impl(const char* expr, const char* what, const char*
 # pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
-// specialize test output for char pointers to avoid printing as cstring
-template <class T> inline const T& test_output_impl(const T& v) { return v; }
-inline const void* test_output_impl(const char* v) { return v; }
-inline const void* test_output_impl(const unsigned char* v) { return v; }
-inline const void* test_output_impl(const signed char* v) { return v; }
-inline const void* test_output_impl(char* v) { return v; }
-inline const void* test_output_impl(unsigned char* v) { return v; }
-inline const void* test_output_impl(signed char* v) { return v; }
-template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
+// specialize test output for pointers to avoid printing as cstring
+
+template<class T> inline T const& test_output_impl( T const& v ) { return v; }
+
+template<class T> inline void const* test_output_impl( T* const& v ) { return v; }
+template<class T> inline void const* test_output_impl( T volatile* const& v ) { return const_cast<T*>(v); }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
-inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
+inline const void* test_output_impl( std::nullptr_t ) { return nullptr; }
 #endif
 
 // print chars as numeric
@@ -210,6 +207,16 @@ inline std::string test_output_impl( char const& v )
     }
 }
 
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+inline std::string test_output_impl( char8_t const& v )
+{
+    // assume that char is ASCII, compatible with char8_t
+    return test_output_impl( static_cast<char>( v ) );
+}
+
+#endif
+
 // predicates
 
 struct lw_test_eq

data/src/cxx_supportlib/vendor-modified/boost/date_time/period.hpp

@@ -299,9 +299,7 @@ namespace date_time {
   inline BOOST_CXX14_CONSTEXPR
   bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
   { 
-    return ( contains(other.begin_) ||
-             other.contains(begin_) ||
-             ((other.begin_ < begin_) && (other.last_ >= begin_)));
+    return !is_null() && !other.is_null() && (begin_ < other.end()) && (other.begin_ < end());
   }
 
   //! Returns the period of intersection or invalid range no intersection

data/src/cxx_supportlib/vendor-modified/boost/describe/detail/config.hpp

@@ -45,4 +45,20 @@
 
 #define BOOST_DESCRIBE_INLINE_CONSTEXPR BOOST_DESCRIBE_INLINE_VARIABLE BOOST_DESCRIBE_CONSTEXPR_OR_CONST
 
+#if __cplusplus >= 202002L || ( defined(_MSVC_LANG) && _MSVC_LANG >= 202002L )
+
+# define BOOST_DESCRIBE_CXX20
+
+// Clang 13.0 is needed for unevaluated lambdas
+# if defined(__clang__) && __clang_major__ < 13
+#  undef BOOST_DESCRIBE_CXX20
+# endif
+
+// Apple Clang 13.1 is Clang 13.0
+# if defined(__clang__) && defined(__apple_build_version__) && __clang_major__ == 13 && __clang_minor__ < 1
+#  undef BOOST_DESCRIBE_CXX20
+# endif
+
+#endif
+
 #endif // #ifndef BOOST_DESCRIBE_DETAIL_CONFIG_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/exception/detail/encoder.hpp

@@ -0,0 +1,114 @@
+//Copyright (c) 2006-2026 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#ifndef BOOST_EXCEPTION_DETAIL_ENCODER_HPP_INCLUDED
+#define BOOST_EXCEPTION_DETAIL_ENCODER_HPP_INCLUDED
+
+#include <boost/exception/detail/type_info.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace
+boost
+    {
+    template <class Tag, class T> class error_info;
+
+    namespace
+    exception_serialization
+        {
+        struct encoder_adl {};
+        }
+
+    namespace
+    exception_detail
+        {
+        template <class T>
+        struct first_arg;
+
+        template <class C, class R, class A1, class... A>
+        struct
+        first_arg<R(C::*)(A1, A...)>
+            {
+            using type = A1;
+            };
+
+        template <class C, class R, class A1, class... A>
+        struct
+        first_arg<R(C::*)(A1, A...) const>
+            {
+            using type = A1;
+            };
+
+        class
+        encoder:
+            exception_serialization::encoder_adl
+            {
+            encoder(encoder const &) = delete;
+            encoder & operator=(encoder const &) = delete;
+
+            core::typeinfo const * type_;
+            void * e_;
+
+            bool
+            dispatch_()
+                {
+                return false;
+                }
+
+            template <class F1, class... Fn>
+            bool
+            dispatch_(F1 && f1, Fn && ... fn)
+                {
+                using encoder_type = typename std::decay<typename first_arg<decltype(&std::decay<F1>::type::operator())>::type>::type;
+                if (encoder_type * e = get<encoder_type>())
+                    {
+                    std::forward<F1>(f1)(*e);
+                    return true;
+                    }
+                return dispatch_(std::forward<Fn>(fn)...);
+                }
+
+            protected:
+
+            template <class Encoder>
+            explicit
+            encoder(Encoder * e) noexcept:
+                type_(&BOOST_CORE_TYPEID(Encoder)),
+                e_(e)
+                {
+                }
+
+            public:
+
+            template <class Encoder>
+            Encoder *
+            get() noexcept
+                {
+                return *type_ == BOOST_CORE_TYPEID(Encoder) ? static_cast<Encoder *>(e_) : nullptr;
+                }
+
+            template <class... Fn>
+            bool
+            dispatch(Fn && ... fn)
+                {
+                return dispatch_(std::forward<Fn>(fn)...);
+                }
+            };
+
+        template <class Encoder>
+        struct
+        encoder_adaptor:
+            encoder
+            {
+            explicit
+            encoder_adaptor(Encoder & e) noexcept:
+                encoder(&e)
+                {
+                }
+            };
+        }
+    }
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/exception/detail/error_info_impl.hpp

@@ -13,6 +13,8 @@
 #include <utility>
 #include <string>
 
+namespace boost { namespace exception_detail { class encoder; } }
+
 #ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
 #if defined(__GNUC__) && __GNUC__*100+__GNUC_MINOR__>301
 #pragma GCC system_header
@@ -38,6 +40,7 @@ boost
 
             virtual std::string name_value_string() const = 0;
             virtual error_info_base * clone() const = 0;
+            virtual void serialize_to(encoder &) const = 0;
 
             virtual
             ~error_info_base() BOOST_NOEXCEPT_OR_NOTHROW
@@ -97,6 +100,7 @@ boost
         error_info & operator=( error_info && x );
 #endif
         std::string name_value_string() const;
+        void serialize_to(exception_detail::encoder &) const;
         value_type v_;
         };
     }

data/src/cxx_supportlib/vendor-modified/boost/exception/detail/requires_cxx11.hpp

@@ -21,4 +21,4 @@ BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.Exception 1.85 and w
 
 #endif
 
-#endif
+#endif

data/src/cxx_supportlib/vendor-modified/boost/exception/detail/type_info.hpp

@@ -11,7 +11,17 @@
 #include <boost/core/demangle.hpp>
 #include <boost/current_function.hpp>
 #include <string>
-#include <string.h>
+#include <ostream>
+#include <cstring>
+#include <cstddef>
+
+#ifndef BOOST_EXCEPTION_PRETTY_FUNCTION
+#   if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+#       define BOOST_EXCEPTION_PRETTY_FUNCTION __FUNCSIG__
+#   else
+#       define BOOST_EXCEPTION_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#   endif
+#endif
 
 #ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
 #if defined(__GNUC__) && __GNUC__*100+__GNUC_MINOR__>301
@@ -73,6 +83,206 @@ boost
                 return a.type_!=b.type_ && strcmp(a.type_->name(), b.type_->name()) < 0;
                 }
             };
+
+        template <int S1, int S2, int I, bool = (S1 >= S2)>
+        struct
+        cpp11_prefix
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&)[S1], char const (&)[S2]) noexcept
+                {
+                return false;
+                }
+            };
+
+        template <int S1, int S2, int I>
+        struct
+        cpp11_prefix<S1, S2, I, true>
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&str)[S1], char const (&prefix)[S2]) noexcept
+                {
+                return str[I] == prefix[I] && cpp11_prefix<S1, S2, I - 1>::check(str, prefix);
+                }
+            };
+
+        template <int S1, int S2>
+        struct
+        cpp11_prefix<S1, S2, 0, true>
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&str)[S1], char const (&prefix)[S2]) noexcept
+                {
+                return str[0] == prefix[0];
+                }
+            };
+
+        template <int S1, int S2>
+        BOOST_FORCEINLINE constexpr
+        int
+        check_prefix(char const (&str)[S1], char const (&prefix)[S2]) noexcept
+            {
+            return cpp11_prefix<S1, S2, S2 - 2>::check(str, prefix) ? S2 - 1 : 0;
+            }
+
+        template <int S1, int S2, int I1, int I2, bool = (S1 >= S2)>
+        struct
+        cpp11_suffix
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&)[S1], char const (&)[S2]) noexcept
+                {
+                return false;
+                }
+            };
+
+        template <int S1, int S2, int I1, int I2>
+        struct
+        cpp11_suffix<S1, S2, I1, I2, true>
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+                {
+                return str[I1] == suffix[I2] && cpp11_suffix<S1, S2, I1 - 1, I2 - 1>::check(str, suffix);
+                }
+            };
+
+        template <int S1, int S2, int I1>
+        struct
+        cpp11_suffix<S1, S2, I1, 0, true>
+            {
+            BOOST_FORCEINLINE static constexpr
+            bool
+            check(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+                {
+                return str[I1] == suffix[0];
+                }
+            };
+
+        template <int S1, int S2>
+        BOOST_FORCEINLINE constexpr
+        int
+        check_suffix(char const (&str)[S1], char const (&suffix)[S2]) noexcept
+            {
+            return cpp11_suffix<S1, S2, S1 - 2, S2 - 2>::check(str, suffix) ? S1 - S2 : 0;
+            }
+
+        }
+
+    namespace
+    n
+        {
+        struct
+        r
+            {
+            char const * name_not_zero_terminated_at_length;
+            std::size_t length;
+            };
+
+#ifdef _MSC_VER
+#   define BOOST_EXCEPTION_CDECL __cdecl
+#else
+#   define BOOST_EXCEPTION_CDECL
+#endif
+
+        template <class T>
+        BOOST_FORCEINLINE
+        r
+        BOOST_EXCEPTION_CDECL
+        p()
+            {
+#define BOOST_EXCEPTION_P(P) (sizeof(char[1 + exception_detail::check_prefix(BOOST_EXCEPTION_PRETTY_FUNCTION, P)]) - 1)
+            // clang style:
+            std::size_t const p01 = BOOST_EXCEPTION_P("r boost::n::p() [T = ");
+            std::size_t const p02 = BOOST_EXCEPTION_P("r __cdecl boost::n::p(void) [T = ");
+            // old clang style:
+            std::size_t const p03 = BOOST_EXCEPTION_P("boost::n::r boost::n::p() [T = ");
+            std::size_t const p04 = BOOST_EXCEPTION_P("boost::n::r __cdecl boost::n::p(void) [T = ");
+            // gcc style:
+            std::size_t const p05 = BOOST_EXCEPTION_P("boost::n::r boost::n::p() [with T = ");
+            std::size_t const p06 = BOOST_EXCEPTION_P("boost::n::r __cdecl boost::n::p() [with T = ");
+            // msvc style, struct:
+            std::size_t const p07 = BOOST_EXCEPTION_P("struct boost::n::r __cdecl boost::n::p<struct ");
+            // msvc style, class:
+            std::size_t const p08 = BOOST_EXCEPTION_P("struct boost::n::r __cdecl boost::n::p<class ");
+            // msvc style, enum:
+            std::size_t const p09 = BOOST_EXCEPTION_P("struct boost::n::r __cdecl boost::n::p<enum ");
+            // msvc style, built-in type:
+            std::size_t const p10 = BOOST_EXCEPTION_P("struct boost::n::r __cdecl boost::n::p<");
+#undef BOOST_EXCEPTION_P
+
+#define BOOST_EXCEPTION_S(S) (sizeof(char[1 + exception_detail::check_suffix(BOOST_EXCEPTION_PRETTY_FUNCTION, S)]) - 1)
+            // clang/gcc style:
+            std::size_t const s01 = BOOST_EXCEPTION_S("]");
+            // msvc style:
+            std::size_t const s02 = BOOST_EXCEPTION_S(">(void)");
+#undef BOOST_EXCEPTION_S
+
+            char static_assert_unrecognized_pretty_function_format_please_file_github_issue[sizeof(
+                char[
+                    (s01 && (1 == (!!p01 + !!p02 + !!p03 + !!p04 + !!p05 + !!p06)))
+                    ||
+                    (s02 && (1 == (!!p07 + !!p08 + !!p09)))
+                    ||
+                    (s02 && !!p10)
+                ]
+            ) * 2 - 1];
+            (void) static_assert_unrecognized_pretty_function_format_please_file_github_issue;
+
+            if( std::size_t const p = sizeof(char[1 + !!s01 * (p01 + p02 + p03 + p04 + p05 + p06)]) - 1 )
+                return { &BOOST_EXCEPTION_PRETTY_FUNCTION[p], s01 - p };
+
+            if( std::size_t const p = sizeof(char[1 + !!s02 * (p07 + p08 + p09)]) - 1 )
+                return { &BOOST_EXCEPTION_PRETTY_FUNCTION[p], s02 - p };
+
+            std::size_t const p = sizeof(char[1 + !!s02 * p10]) - 1;
+            return { &BOOST_EXCEPTION_PRETTY_FUNCTION[p], s02 - p };
+            }
+
+#undef BOOST_EXCEPTION_CDECL
+        }
+
+    namespace
+    exception_detail
+        {
+        struct
+        pretty_type_name
+            {
+            char const * name_not_zero_terminated_at_length;
+            std::size_t length;
+
+            template <class CharT, class Traits>
+            friend
+            std::basic_ostream<CharT, Traits> &
+            operator<<(std::basic_ostream<CharT, Traits> & os, pretty_type_name const & x)
+                {
+                return os.write(x.name_not_zero_terminated_at_length, x.length);
+                }
+
+            template <std::size_t S>
+            friend
+            char *
+            to_zstr(char (&zstr)[S], pretty_type_name const & x) noexcept
+                {
+                std::size_t n = x.length < S - 1 ? x.length : S - 1;
+                std::memcpy(zstr, x.name_not_zero_terminated_at_length, n);
+                zstr[n] = 0;
+                return zstr;
+                }
+            };
+
+        template <class T>
+        pretty_type_name
+        get_pretty_tag_type_name()
+            {
+            n::r parsed = n::p<T>();
+            return { parsed.name_not_zero_terminated_at_length, parsed.length };
+            }
         }
     }
 

data/src/cxx_supportlib/vendor-modified/boost/exception/diagnostic_information.hpp

@@ -205,6 +205,65 @@ boost
 #endif
         return w;
         }
+
+    namespace
+    exception_detail
+        {
+        template <class Encoder>
+        void
+        serialize_diagnostic_information_to_impl_( boost::exception const * be, std::exception const * se, Encoder & e )
+            {
+            if( !be && !se )
+                return;
+#ifndef BOOST_NO_RTTI
+            if( !be )
+                be=dynamic_cast<boost::exception const *>(se);
+            if( !se )
+                se=dynamic_cast<std::exception const *>(be);
+#endif
+            if( be )
+                {
+                if( char const * const * f=get_error_info<throw_file>(*be) )
+                    output_at(e, *f, "throw_file");
+                if( int const * l=get_error_info<throw_line>(*be) )
+                    output_at(e, *l, "throw_line");
+                if( char const * const * fn=get_error_info<throw_function>(*be) )
+                    output_at(e, *fn, "throw_function");
+                }
+#ifndef BOOST_NO_RTTI
+            if( be || se )
+                output_at(e, core::demangle((be?(BOOST_EXCEPTION_DYNAMIC_TYPEID(*be)):(BOOST_EXCEPTION_DYNAMIC_TYPEID(*se))).type_->name()).c_str(), "dynamic_exception_type");
+#endif
+            if( se )
+                if( char const * wh = se->what() )
+                    output_at(e, wh, "std::exception::what");
+            if( be )
+                if( error_info_container * c = be->data_.get() )
+                    {
+                    encoder_adaptor<Encoder> ea(e);
+                    c->serialize_to(ea);
+                    }
+            }
+        }
+
+    template <class T, class Encoder>
+    void
+    serialize_diagnostic_information_to( T const & e, Encoder & enc )
+        {
+        exception_detail::serialize_diagnostic_information_to_impl_(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),enc);
+        }
+
+#ifndef BOOST_NO_EXCEPTIONS
+    template <class Encoder>
+    void
+    serialize_current_exception_diagnostic_information_to( Encoder & e )
+        {
+        boost::exception const * be=current_exception_cast<boost::exception const>();
+        std::exception const * se=current_exception_cast<std::exception const>();
+        if( be || se )
+            exception_detail::serialize_diagnostic_information_to_impl_(be,se,e);
+        }
+#endif
     }
 
 #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)

data/src/cxx_supportlib/vendor-modified/boost/exception/exception.hpp

@@ -175,6 +175,7 @@ boost
         {
         class error_info_base;
         struct type_info_;
+        class encoder;
 
         struct
         error_info_container
@@ -185,6 +186,7 @@ boost
             virtual void add_ref() const = 0;
             virtual bool release() const = 0;
             virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
+            virtual void serialize_to( encoder & ) const { }
 
             protected:
 
@@ -227,6 +229,9 @@ boost
 
         void copy_boost_exception( exception *, exception const * );
 
+        template <class Encoder>
+        void serialize_diagnostic_information_to_impl_( exception const *, std::exception const *, Encoder & );
+
         template <class E,class Tag,class T>
         E const & set_info( E const &, error_info<Tag,T> const & );
 
@@ -321,6 +326,7 @@ boost
         friend struct exception_detail::set_info_rv<throw_line>;
         friend struct exception_detail::set_info_rv<throw_column>;
         friend void exception_detail::copy_boost_exception( exception *, exception const * );
+        template <class Encoder> friend void exception_detail::serialize_diagnostic_information_to_impl_( exception const *, std::exception const *, Encoder & );
 #endif
         mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
         mutable char const * throw_function_;

data/src/cxx_supportlib/vendor-modified/boost/exception/info.hpp

@@ -11,7 +11,9 @@
 #include <boost/exception/to_string_stub.hpp>
 #include <boost/exception/detail/error_info_impl.hpp>
 #include <boost/exception/detail/shared_ptr.hpp>
+#include <boost/exception/detail/encoder.hpp>
 #include <map>
+#include <type_traits>
 
 #ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
 #if defined(__GNUC__) && __GNUC__*100+__GNUC_MINOR__>301
@@ -28,6 +30,17 @@
 namespace
 boost
     {
+    namespace
+    exception_serialization
+        {
+        // Stub
+        template <class Encoder, class T, class... Deprioritize>
+        typename std::enable_if<std::is_base_of<exception_detail::encoder, Encoder>::value>::type
+        serialize(Encoder &, T const &, char const *, Deprioritize...)
+            {
+            }
+        }
+
     template <class Tag,class T>
     inline
     std::string
@@ -53,6 +66,17 @@ boost
         return to_string_stub(*this);
         }
 
+    template <class Tag,class T>
+    inline
+    void
+    error_info<Tag,T>::
+    serialize_to(exception_detail::encoder & e) const
+        {
+        char buf[256];
+        using namespace exception_serialization;
+        serialize(e, value(), to_zstr(buf, exception_detail::get_pretty_tag_type_name<Tag>()));
+        }
+
     namespace
     exception_detail
         {
@@ -108,6 +132,16 @@ boost
                 return diagnostic_info_str_.c_str();
                 }
 
+            void
+            serialize_to( encoder & e ) const
+                {
+                for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
+                    {
+                    error_info_base const & x = *i->second;
+                    x.serialize_to(e);
+                    }
+                }
+
             private:
 
             friend class boost::exception;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/avltree.hpp

@@ -22,7 +22,6 @@
 #include <boost/intrusive/detail/avltree_node.hpp>
 #include <boost/intrusive/bstree.hpp>
 #include <boost/intrusive/detail/tree_node.hpp>
-#include <boost/intrusive/detail/ebo_functor_holder.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/get_value_traits.hpp>

data/src/cxx_supportlib/vendor-modified/boost/intrusive/bstree.hpp

@@ -585,8 +585,11 @@ struct bstbase
    //Detach all inserted nodes. This will add exception safety to bstree_impl
    //constructors inserting elements.
    ~bstbase()
+   #if defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+      requires (ValueTraits::link_mode != normal_link)
+   #endif
    {
-      if(is_safe_autounlink<value_traits::link_mode>::value){
+      BOOST_IF_CONSTEXPR(is_safe_autounlink<value_traits::link_mode>::value){
          node_algorithms::clear_and_dispose
             ( this->header_ptr()
             , detail::node_disposer<detail::null_disposer, value_traits, AlgoType>
@@ -594,6 +597,11 @@ struct bstbase
          node_algorithms::init(this->header_ptr());
       }
    }
+
+   #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) && defined(BOOST_INTRUSIVE_CONCEPTS_BASED_OVERLOADING)
+   //Default destructor for normal links (allows conditional triviality)
+   ~bstbase() requires (ValueTraits::link_mode == normal_link) = default;
+   #endif
 };
 
 
@@ -947,7 +955,7 @@ class bstree_impl
    //! <b>Throws</b>: Nothing.
    bool empty() const BOOST_NOEXCEPT
    {
-      if(ConstantTimeSize){
+      BOOST_IF_CONSTEXPR(constant_time_size){
          return !this->data_type::sz_traits().get_size();
       }
       else{
@@ -2073,7 +2081,8 @@ class bstree_impl
 
    friend bool operator==(const bstree_impl &x, const bstree_impl &y)
    {
-      if(constant_time_size && x.size() != y.size()){
+      BOOST_IF_CONSTEXPR(constant_time_size)
+      if(x.size() != y.size()){
          return false;
       }
       return boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());

data/src/cxx_supportlib/vendor-modified/boost/intrusive/derivation_value_traits.hpp

@@ -56,7 +56,7 @@ struct derivation_value_traits
    { return node_ptr(&value); }
 
    BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) BOOST_NOEXCEPT
-   { return node_ptr(&value); }
+   { return const_node_ptr(&value); }
 
    BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) BOOST_NOEXCEPT
    {