passenger 6.0.26 → 6.1.0

data/src/cxx_supportlib/vendor-modified/boost/container/stable_vector.hpp

@@ -597,6 +597,11 @@ class stable_vector
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits<allocator_type>::value_type>::value));
+
    BOOST_COPYABLE_AND_MOVABLE(stable_vector)
    BOOST_STATIC_CONSTEXPR size_type ExtraPointers = index_traits_type::ExtraPointers;
 
@@ -2177,11 +2182,11 @@ class stable_vector
                               , node_ptr_traits::static_cast_from(pool_first_ref)
                               , node_ptr_traits::static_cast_from(pool_last_ref)
                               , internal_data.pool_size);
-      typename multiallocation_chain::iterator beg(holder.begin()), end(holder.end());
+      typename multiallocation_chain::iterator b(holder.begin()), e(holder.end());
       size_type num_pool = 0;
-      while(beg != end){
+      while(b != e){
          ++num_pool;
-         ++beg;
+         ++b;
       }
       return n >= num_pool && num_pool == internal_data.pool_size;
    }

data/src/cxx_supportlib/vendor-modified/boost/container/static_vector.hpp

@@ -102,6 +102,19 @@ struct get_static_vector_opt<void>
    typedef static_vector_null_opt type;
 };
 
+template<class Options>
+struct get_vector_opt_from_static_vector_opt
+{
+   typedef typename get_static_vector_opt<Options>::type options_t;
+   typedef vector_opt<void, typename options_t::stored_size_type> type;
+};
+
+template<>
+struct get_vector_opt_from_static_vector_opt<void>
+{
+   typedef void type;
+};
+
 template <typename T, std::size_t Capacity, class Options>
 struct get_static_vector_allocator
 {
@@ -114,7 +127,6 @@ struct get_static_vector_allocator
       > type;
 };
 
-
 }  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -148,12 +160,18 @@ struct get_static_vector_allocator
 //! is specified, by default throw_on_overflow<true> option is set.
 template <typename T, std::size_t Capacity, class Options BOOST_CONTAINER_DOCONLY(= void) >
 class static_vector
-    : public vector<T, typename dtl::get_static_vector_allocator< T, Capacity, Options>::type>
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+    : public vector< T
+                   , typename dtl::get_static_vector_allocator< T, Capacity, Options>::type
+                   , typename dtl::get_vector_opt_from_static_vector_opt<Options>::type
+                   >
+   #endif
 {
    public:
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename dtl::get_static_vector_allocator< T, Capacity, Options>::type allocator_type;
-   typedef vector<T, allocator_type > base_t;
+   typedef typename dtl::get_vector_opt_from_static_vector_opt<Options>::type options_type;
+   typedef vector<T, allocator_type, options_type> base_t;
 
    BOOST_COPYABLE_AND_MOVABLE(static_vector)
 

data/src/cxx_supportlib/vendor-modified/boost/container/string.hpp

@@ -628,6 +628,11 @@ class basic_string
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits<allocator_type>::value_type>::value));
+
    typedef constant_iterator<CharT> cvalue_iterator;
    typedef typename base_t::alloc_version  alloc_version;
    typedef ::boost::intrusive::pointer_traits<pointer> pointer_traits;
@@ -3545,21 +3550,6 @@ getline(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,Allocat
    return getline(is, s, '\n');
 }
 
-template <class Ch, class Allocator>
-inline std::size_t hash_value(basic_string<Ch, std::char_traits<Ch>, Allocator> const& v)
-{
-   std::size_t seed = 0;
-   const Ch *first = v.data();
-
-   for(std::size_t i = 0, i_max = v.size(); i != i_max; ++i)
-   {
-      boost::intrusive::detail::hash_combine_size_t(seed, static_cast<std::size_t>(*first));
-      ++first;
-   }
-
-   return seed;
-}
-
 }}
 
 //GCC 12 has a regression for array-bounds warnings

data/src/cxx_supportlib/vendor-modified/boost/container/vector.hpp

@@ -643,7 +643,7 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
    template<class AllocConvertible>
    vector_alloc_holder(vector_uninitialized_size_t, BOOST_FWD_REF(AllocConvertible) a, size_type initial_size)
       : allocator_type(boost::forward<AllocConvertible>(a))
-      , m_size(initial_size)  //Size is initialized here...
+      , m_size(static_cast<stored_size_type>(initial_size))  //Size is initialized here...
    {
       //... and capacity here, so vector, must call uninitialized_xxx in the derived constructor
       this->priv_first_allocation(initial_size);
@@ -652,7 +652,7 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
    //Constructor, does not throw
    vector_alloc_holder(vector_uninitialized_size_t, size_type initial_size)
       : allocator_type()
-      , m_size(initial_size)  //Size is initialized here...
+      , m_size(static_cast<stored_size_type>(initial_size))  //Size is initialized here...
    {
       //... and capacity here, so vector, must call uninitialized_xxx in the derived constructor
       this->priv_first_allocation(initial_size);
@@ -813,8 +813,11 @@ public:
    typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<const_iterator>)  const_reverse_iterator;
 
 private:
-
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits_t::value_type>::value));
+
    typedef typename boost::container::
       allocator_traits<allocator_type>::size_type                             alloc_size_type;
    typedef typename get_vector_opt<Options, alloc_size_type>::type            options_type;
@@ -2315,6 +2318,7 @@ private:
       return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(size_type(new_cap - cp)));
    }
 
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    //Absolutely experimental. This function might change, disappear or simply crash!
    template<class BiDirPosConstIt, class BiDirValueIt>
    inline void insert_ordered_at(const size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
@@ -2328,32 +2332,48 @@ private:
    {  this->merge(first, last, value_less_t());  }
 
    template<class InputIt, class Compare>
-   inline void merge(InputIt first, InputIt last, Compare comp)
+   inline 
+      typename dtl::enable_if_c
+         < !dtl::is_input_iterator<InputIt>::value &&
+           dtl::is_same<value_type, typename iterator_traits<InputIt>::value_type>::value
+         , void>::type
+      merge(InputIt first, InputIt last, Compare comp)
    {
       size_type const s = this->size();
       size_type const c = this->capacity();
       size_type n = 0;
       size_type const free_cap = c - s;
       //If not input iterator and new elements don't fit in the remaining capacity, merge in new buffer
-      if(!dtl::is_input_iterator<InputIt>::value &&
-         free_cap < (n = boost::container::iterator_udistance(first, last))){
+      if(free_cap < (n = boost::container::iterator_udistance(first, last))){
          this->priv_merge_in_new_buffer(first, n, comp, alloc_version());
       }
       else{
-         this->insert(this->cend(), first, last);
-         T *const raw_beg = this->priv_raw_begin();
-         T *const raw_end = this->priv_raw_end();
-         T *const raw_pos = raw_beg + s;
-         boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, free_cap - n);
+         this->priv_merge_generic(first, last, comp);
       }
    }
 
+   template<class InputIt, class Compare>
+   inline 
+      typename dtl::enable_if_c
+         < dtl::is_input_iterator<InputIt>::value ||
+           !dtl::is_same<value_type, typename iterator_traits<InputIt>::value_type>::value
+         , void>::type
+      merge(InputIt first, InputIt last, Compare comp)
+   {
+      this->priv_merge_generic(first, last, comp);
+   }
+
    template<class InputIt>
    inline void merge_unique(InputIt first, InputIt last)
    {  this->merge_unique(first, last, value_less_t());  }
 
    template<class InputIt, class Compare>
-   inline void merge_unique(InputIt first, InputIt last, Compare comp)
+   inline 
+      typename dtl::enable_if_c
+         < !dtl::is_input_iterator<InputIt>::value &&
+           dtl::is_same<value_type, typename iterator_traits<InputIt>::value_type>::value
+         , void>::type
+      merge_unique(InputIt first, InputIt last, Compare comp)
    {
       size_type const old_size = this->size();
       this->priv_set_difference_back(first, last, comp);
@@ -2363,7 +2383,42 @@ private:
       boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, this->capacity() - this->size());
    }
 
+   template<class InputIt, class Compare>
+   inline 
+      typename dtl::enable_if_c
+         < dtl::is_input_iterator<InputIt>::value ||
+           !dtl::is_same<value_type, typename iterator_traits<InputIt>::value_type>::value
+         , void>::type
+      merge_unique(InputIt first, InputIt last, Compare comp)
+   {
+      iterator pos = this->insert(this->end(), first, last);
+      const iterator e = boost::movelib::inplace_set_unique_difference(pos, this->end(), this->begin(), pos, comp);
+      this->erase(e, this->end());
+      boost::movelib::adaptive_merge( this->begin(), pos, e, comp
+                                    , this->priv_raw_end(), this->capacity() - this->size());
+   }
+
+   //Function for optimizations, not for users
+   T *unused_storage(size_type &sz)
+   {
+      sz = static_cast<size_type>(this->capacity() - this->size());
+      return this->priv_raw_end();
+   }
+  
+   #endif
+
    private:
+   template<class InputIt, class Compare>
+   inline void priv_merge_generic(InputIt first, InputIt last, Compare comp)
+   {
+      size_type const old_s = this->size();
+      this->insert(this->cend(), first, last);
+      T* const raw_beg = this->priv_raw_begin();
+      T* const raw_end = this->priv_raw_end();
+      T* const raw_pos = raw_beg + old_s;
+      boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, this->capacity() - this->size());
+   }
+
    template<class PositionValue>
    void priv_insert_ordered_at(const size_type element_count, PositionValue position_value)
    {
@@ -2710,7 +2765,7 @@ private:
             //Move internal memory data to the internal memory data of the target, this can throw
             BOOST_ASSERT(extmem.capacity() >= intmem.size());
             ::boost::container::uninitialized_move_alloc_n
-               (intmem.get_stored_allocator(), this->priv_raw_begin(), intmem.size(), extmem.priv_raw_begin());
+               (intmem.get_stored_allocator(), intmem.priv_raw_begin(), intmem.size(), extmem.priv_raw_begin());
 
             //Exception not thrown, commit new state
             extmem.m_holder.set_stored_size(intmem.size());
@@ -2721,7 +2776,7 @@ private:
 
          //Destroy moved elements from intmem
          boost::container::destroy_alloc_n
-            ( intmem.get_stored_allocator(), this->priv_raw_begin()
+            ( intmem.get_stored_allocator(), intmem.priv_raw_begin()
             , intmem.size());
 
          //Adopt dynamic buffer
@@ -3319,6 +3374,8 @@ struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator,
 //See comments on vec_iterator::element_type to know why is this needed
 #ifdef BOOST_GNU_STDLIB
 
+#include <boost/move/detail/std_ns_begin.hpp>
+
 BOOST_MOVE_STD_NS_BEG
 
 template <class Pointer, bool IsConst>
@@ -3328,6 +3385,8 @@ struct pointer_traits< boost::container::vec_iterator<Pointer, IsConst> >
 
 BOOST_MOVE_STD_NS_END
 
+#include <boost/move/detail/std_ns_end.hpp>
+
 #endif   //BOOST_GNU_STDLIB
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

data/src/cxx_supportlib/vendor-modified/boost/detail/basic_pointerbuf.hpp

@@ -19,7 +19,6 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/integer.hpp>
 
 #include <streambuf>
 
@@ -73,7 +72,7 @@ template<class charT, class BufferT>
 typename basic_pointerbuf<charT, BufferT>::pos_type
 basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
 {
-   typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
+   typedef ::std::ios_base::seekdir cast_type;
 
    if(which & ::std::ios_base::out)
       return pos_type(off_type(-1));

data/src/cxx_supportlib/vendor-modified/boost/detail/lcast_precision.hpp

@@ -13,47 +13,43 @@
 #include <limits>
 
 #include <boost/config.hpp>
-#include <boost/integer_traits.hpp>
 
 namespace boost { namespace detail {
 
-class lcast_abstract_stub {};
-
 // Calculate an argument to pass to std::ios_base::precision from
-// lexical_cast. See alternative implementation for broken standard
-// libraries in lcast_get_precision below. Keep them in sync, please.
+// lexical_cast.
 template<class T>
 struct lcast_precision
 {
     using limits = std::numeric_limits<T>;
 
-    BOOST_STATIC_CONSTANT(bool, use_default_precision =
+    static constexpr bool use_default_precision =
             !limits::is_specialized || limits::is_exact
-        );
+        ;
 
-    BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
+    static constexpr bool is_specialized_bin =
             !use_default_precision &&
             limits::radix == 2 && limits::digits > 0
-        );
+        ;
 
-    BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
+    static constexpr bool is_specialized_dec =
             !use_default_precision &&
             limits::radix == 10 && limits::digits10 > 0
-        );
+        ;
 
-    BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
-            boost::integer_traits<std::streamsize>::const_max
-        );
+    static constexpr std::streamsize streamsize_max =
+            (std::numeric_limits<std::streamsize>::max)()
+        ;
 
-    BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
+    static constexpr unsigned int precision_dec = limits::digits10 + 1U;
 
     static_assert(!is_specialized_dec ||
             precision_dec <= streamsize_max + 0UL
         , "");
 
-    BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
+    static constexpr unsigned long precision_bin =
             2UL + limits::digits * 30103UL / 100000UL
-        );
+        ;
 
     static_assert(!is_specialized_bin ||
             (limits::digits + 0UL < ULONG_MAX / 30103UL &&
@@ -61,30 +57,23 @@ struct lcast_precision
             precision_bin <= streamsize_max + 0UL)
         , "");
 
-    BOOST_STATIC_CONSTANT(std::streamsize, value =
+    static constexpr std::streamsize value =
             is_specialized_bin ? precision_bin
                                : is_specialized_dec ? precision_dec : 6
-        );
+        ;
 };
 
-
-template<class T>
-inline std::streamsize lcast_get_precision(T* = 0)
-{
-    return lcast_precision<T>::value;
-}
-
 template<class T>
 inline void lcast_set_precision(std::ios_base& stream, T*)
 {
-    stream.precision(lcast_get_precision<T>());
+    stream.precision(lcast_precision<T>::value);
 }
 
 template<class Source, class Target>
 inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
 {
-    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
-    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
+    std::streamsize const s = lcast_precision<Source>::value;
+    std::streamsize const t = lcast_precision<Target*>::value;
     stream.precision(s > t ? s : t);
 }
 

data/src/cxx_supportlib/vendor-modified/boost/function/function_template.hpp

@@ -261,9 +261,9 @@ namespace boost {
          actual invoker that will be used for the given function
          object.
 
-         Each specialization contains an "apply" nested class template
+         Each specialization contains an "apply_" nested class template
          that accepts the function object, return type, function
-         argument types, and allocator. The resulting "apply" class
+         argument types, and allocator. The resulting "apply_" class
          contains two typedefs, "invoker_type" and "manager_type",
          which correspond to the invoker and manager types. */
       template<typename Tag>
@@ -275,7 +275,7 @@ namespace boost {
       {
         template<typename FunctionPtr,
                  typename R, typename... T>
-        struct apply
+        struct apply_
         {
           typedef typename get_function_invoker<
                              FunctionPtr,
@@ -308,7 +308,7 @@ namespace boost {
       {
         template<typename MemberPtr,
                  typename R, typename... T>
-        struct apply
+        struct apply_
         {
           typedef typename get_member_invoker<
                              MemberPtr,
@@ -341,7 +341,7 @@ namespace boost {
       {
         template<typename FunctionObj,
                  typename R, typename... T>
-        struct apply
+        struct apply_
         {
           typedef typename get_function_obj_invoker<
                              FunctionObj,
@@ -374,7 +374,7 @@ namespace boost {
       {
         template<typename RefWrapper,
                  typename R, typename... T>
-        struct apply
+        struct apply_
         {
           typedef typename get_function_ref_invoker<
                              typename RefWrapper::type,
@@ -923,7 +923,7 @@ namespace boost {
       typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
       typedef boost::detail::function::get_invoker<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply<Functor, R,
+                         template apply_<Functor, R,
                         T...>
         handler_type;
 

data/src/cxx_supportlib/vendor-modified/boost/integer/common_factor_rt.hpp

@@ -51,19 +51,20 @@ namespace boost {
          //
          // some helper functions which really should be constexpr already, but sadly aren't:
          //
-#ifndef BOOST_NO_CXX14_CONSTEXPR
          template <class T>
-         inline constexpr T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
+         inline BOOST_CONSTEXPR T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
          {
             return a < b ? a : b;
          }
+
+#ifndef BOOST_NO_CXX14_CONSTEXPR
          template <class T>
-         inline constexpr auto constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T) -> decltype(a.swap(b))
+         inline constexpr auto constexpr_swap(T& a, T& b) BOOST_GCD_NOEXCEPT(T) -> decltype(a.swap(b))
          {
             return a.swap(b);
          }
          template <class T, class U>
-         inline constexpr void constexpr_swap(T&a, U& b...) BOOST_GCD_NOEXCEPT(T)
+         inline constexpr void constexpr_swap(T& a, U& b, ...) BOOST_GCD_NOEXCEPT(T)
          {
             T t(static_cast<T&&>(a));
             a = static_cast<T&&>(b);
@@ -71,12 +72,7 @@ namespace boost {
          }
 #else
          template <class T>
-         inline T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
-         {
-            return a < b ? a : b;
-         }
-         template <class T>
-         inline void constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T)
+         inline void constexpr_swap(T& a, T& b) BOOST_GCD_NOEXCEPT(T)
          {
             using std::swap;
             swap(a, b);

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

@@ -554,15 +554,19 @@ class avl_set
    inline void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avl_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avl_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avl_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<avl_set &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avl_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const avl_set &>(Base::container_from_iterator(it));   }
 };
@@ -1049,15 +1053,19 @@ class avl_multiset
    inline void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avl_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avl_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avl_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<avl_multiset &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avl_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const avl_multiset &>(Base::container_from_iterator(it));   }
 };

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

@@ -564,15 +564,19 @@ class avltree
    inline void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<avltree &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const avltree &>(Base::container_from_iterator(it));   }
 };

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

@@ -551,15 +551,19 @@ class bs_set
    inline void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bs_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bs_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const bs_set &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bs_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<bs_set &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bs_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const bs_set &>(Base::container_from_iterator(it));   }
 };
@@ -1045,15 +1049,19 @@ class bs_multiset
    inline void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bs_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bs_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const bs_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bs_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<bs_multiset &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bs_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const bs_multiset &>(Base::container_from_iterator(it));   }
 };

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

@@ -876,7 +876,8 @@ class bstree_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   static bstree_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   static bstree_impl& container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {
       return static_cast<bstree_impl&>
                (data_type::get_tree_base_from_end_iterator(end_iterator));
@@ -890,7 +891,8 @@ class bstree_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   static const bstree_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   static const bstree_impl & container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {
       return static_cast<bstree_impl&>
                (data_type::get_tree_base_from_end_iterator(end_iterator));
@@ -904,7 +906,8 @@ class bstree_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   static bstree_impl &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   static bstree_impl & container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return container_from_end_iterator(it.end_iterator_from_it());   }
 
    //! <b>Precondition</b>: it must be a valid end const_iterator
@@ -915,7 +918,8 @@ class bstree_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   static const bstree_impl &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_NO_DANGLING
+   static const bstree_impl & container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return container_from_end_iterator(it.end_iterator_from_it());   }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -2215,15 +2219,19 @@ class bstree
    inline void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<bstree &>(Base::container_from_iterator(it));   }
 
+   BOOST_INTRUSIVE_NO_DANGLING
    inline static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const bstree &>(Base::container_from_iterator(it));   }
 };

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/function_detector.hpp

@@ -78,7 +78,7 @@ namespace function_detector {
       template <class U> \
       static NotFoundType Test( ... ); \
    public : \
-      static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
+      static const int check = NotFound + int(sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
    };\
 }}} //namespace boost::intrusive::function_detector {