Update contrib/restricted/boost/function to 1.80.0

4 files changed, 137 insertions, 86 deletions

diff --git a/contrib/restricted/boost/function/README.md b/contrib/restricted/boost/function/README.md
new file mode 100644
index 00000000000..6b1bb443c39
--- /dev/null
+++ b/contrib/restricted/boost/function/README.md
@@ -0,0 +1,18 @@
+# Boost.Function, a polymorphic function wrapper
+
+[Boost.Function](http://boost.org/libs/function), part of the
+[Boost C++ Libraries](http://boost.org), is the original implementation of the
+polymorphic function wrapper `boost::function`, which was eventually accepted
+into the C++11 standard as [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function).
+
+## Currently supported compilers
+
+* g++ 4.8 or later
+* clang++ 3.9 or later
+* Visual Studio 2005-2022
+
+Tested on [Github Actions](https://github.com/boostorg/function/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/).
+
+## License
+
+Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
diff --git a/contrib/restricted/boost/function/include/boost/function.hpp b/contrib/restricted/boost/function/include/boost/function.hpp
index 68a25ab0696..ef907e0ff15 100644
--- a/contrib/restricted/boost/function/include/boost/function.hpp
+++ b/contrib/restricted/boost/function/include/boost/function.hpp
@@ -23,7 +23,7 @@
 #include <functional> // unary_function, binary_function
 
 #include <boost/preprocessor/iterate.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 // Include the prologue here so that the use of file-level iteration
 // in anything that may be included by function_template.hpp doesn't break
diff --git a/contrib/restricted/boost/function/include/boost/function/function_base.hpp b/contrib/restricted/boost/function/include/boost/function/function_base.hpp
index 841affb49a5..14185323d45 100644
--- a/contrib/restricted/boost/function/include/boost/function/function_base.hpp
+++ b/contrib/restricted/boost/function/include/boost/function/function_base.hpp
@@ -26,13 +26,13 @@
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
 #include <boost/ref.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #ifndef BOOST_NO_SFINAE
-#  include "boost/utility/enable_if.hpp"
+#include <boost/type_traits/enable_if.hpp>
 #else
-#  include "boost/mpl/bool.hpp"
+#include <boost/type_traits/integral_constant.hpp>
 #endif
 #include <boost/function_equal.hpp>
 #include <boost/function/function_fwd.hpp>
@@ -50,7 +50,7 @@
 #endif // __ICL etc
 
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<          \
+      typename ::boost::enable_if_<          \
                            !(::boost::is_integral<Functor>::value), \
                            Type>::type
 
@@ -86,12 +86,21 @@ namespace boost {
         typedef void (*func_ptr_t)();
         mutable func_ptr_t func_ptr;
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(push)
+# pragma warning(disable: 5243)
+#endif
+
         // For bound member pointers
         struct bound_memfunc_ptr_t {
           void (X::*memfunc_ptr)(int);
           void* obj_ptr;
         } bound_memfunc_ptr;
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(pop)
+#endif
+
         // For references to function objects. We explicitly keep
         // track of the cv-qualifiers on the object referenced.
         struct obj_ref_t {
@@ -101,7 +110,7 @@ namespace boost {
         } obj_ref;
       };
 
-      union function_buffer
+      union BOOST_SYMBOL_VISIBLE function_buffer
       {
         // Type-specific union members
         mutable function_buffer_members members;
@@ -152,15 +161,15 @@ namespace boost {
       template<typename F>
       class get_function_tag
       {
-        typedef typename mpl::if_c<(is_pointer<F>::value),
+        typedef typename conditional<(is_pointer<F>::value),
                                    function_ptr_tag,
                                    function_obj_tag>::type ptr_or_obj_tag;
 
-        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+        typedef typename conditional<(is_member_pointer<F>::value),
                                    member_ptr_tag,
                                    ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
 
-        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+        typedef typename conditional<(is_reference_wrapper<F>::value),
                                    function_obj_ref_tag,
                                    ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
@@ -328,7 +337,7 @@ namespace boost {
         // Function objects that fit in the small-object buffer.
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::true_)
+                functor_manager_operation_type op, true_type)
         {
           functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
         }
@@ -336,7 +345,7 @@ namespace boost {
         // Function objects that require heap allocation
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::false_)
+                functor_manager_operation_type op, false_type)
         {
           if (op == clone_functor_tag) {
             // Clone the functor
@@ -377,7 +386,7 @@ namespace boost {
                 functor_manager_operation_type op, function_obj_tag)
         {
           manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
         }
 
         // For member pointers, we use the small-object optimization buffer.
@@ -385,7 +394,7 @@ namespace boost {
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                 functor_manager_operation_type op, member_ptr_tag)
         {
-          manager(in_buffer, out_buffer, op, mpl::true_());
+          manager(in_buffer, out_buffer, op, true_type());
         }
 
       public:
@@ -396,16 +405,12 @@ namespace boost {
                functor_manager_operation_type op)
         {
           typedef typename get_function_tag<functor_type>::type tag_type;
-          switch (op) {
-          case get_functor_type_tag:
+          if (op == get_functor_type_tag) {
             out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
-            return;
-
-          default:
+          } else {
             manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -427,7 +432,7 @@ namespace boost {
         // Function objects that fit in the small-object buffer.
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::true_)
+                functor_manager_operation_type op, true_type)
         {
           functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
         }
@@ -435,7 +440,7 @@ namespace boost {
         // Function objects that require heap allocation
         static inline void
         manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::false_)
+                functor_manager_operation_type op, false_type)
         {
           typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
@@ -499,7 +504,7 @@ namespace boost {
                 functor_manager_operation_type op, function_obj_tag)
         {
           manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
         }
 
       public:
@@ -510,16 +515,12 @@ namespace boost {
                functor_manager_operation_type op)
         {
           typedef typename get_function_tag<functor_type>::type tag_type;
-          switch (op) {
-          case get_functor_type_tag:
+          if (op == get_functor_type_tag) {
             out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
             out_buffer.members.type.const_qualified = false;
             out_buffer.members.type.volatile_qualified = false;
-            return;
-
-          default:
+          } else {
             manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -530,24 +531,24 @@ namespace boost {
 #ifdef BOOST_NO_SFINAE
       // These routines perform comparisons between a Boost.Function
       // object and an arbitrary function object (when the last
-      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is mpl::bool_<true>). They are only necessary
+      // parameter is false_type) or against zero (when the
+      // last parameter is true_type). They are only necessary
       // for compilers that don't support SFINAE.
       template<typename Function, typename Functor>
         bool
-        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        compare_equal(const Function& f, const Functor&, int, true_type)
         { return f.empty(); }
 
       template<typename Function, typename Functor>
         bool
         compare_not_equal(const Function& f, const Functor&, int,
-                          mpl::bool_<true>)
+                          true_type)
         { return !f.empty(); }
 
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const Functor& g, long,
-                      mpl::bool_<false>)
+                      false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return function_equal(*fp, g);
@@ -557,7 +558,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, mpl::bool_<false>)
+                      int, false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp == g.get_pointer();
@@ -567,7 +568,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_not_equal(const Function& f, const Functor& g, long,
-                          mpl::bool_<false>)
+                          false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return !function_equal(*fp, g);
@@ -578,7 +579,7 @@ namespace boost {
         bool
         compare_not_equal(const Function& f,
                           const reference_wrapper<Functor>& g, int,
-                          mpl::bool_<false>)
+                          false_type)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp != g.get_pointer();
@@ -710,7 +711,7 @@ public: // should be protected, but GCC 2.95.3 will fail to allow access
  * The bad_function_call exception class is thrown when a boost::function
  * object is invoked
  */
-class bad_function_call : public std::runtime_error
+class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error
 {
 public:
   bad_function_call() : std::runtime_error("call to empty boost::function") {}
@@ -750,28 +751,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
 template<typename Functor>
   inline bool operator==(const function_base& f, Functor g)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator==(Functor g, const function_base& f)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator!=(const function_base& f, Functor g)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_not_equal(f, g, 0, integral());
   }
 
 template<typename Functor>
   inline bool operator!=(Functor g, const function_base& f)
   {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
     return detail::function::compare_not_equal(f, g, 0, integral());
   }
 #else
diff --git a/contrib/restricted/boost/function/include/boost/function/function_template.hpp b/contrib/restricted/boost/function/include/boost/function/function_template.hpp
index 0b05940b227..dcfc8f00315 100644
--- a/contrib/restricted/boost/function/include/boost/function/function_template.hpp
+++ b/contrib/restricted/boost/function/include/boost/function/function_template.hpp
@@ -11,7 +11,7 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@@ -29,8 +29,7 @@
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
 #else
-#   include <boost/move/utility_core.hpp>
-#   define BOOST_FUNCTION_ARG(J,I,D) ::boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I))
+#   define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
 #   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
 #endif
 
@@ -240,7 +239,7 @@ namespace boost {
       >
       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
                             R BOOST_FUNCTION_COMMA
@@ -261,7 +260,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -282,7 +281,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -305,7 +304,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_MEMBER_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_MEMBER_INVOKER<
                             MemberPtr,
                             R BOOST_FUNCTION_COMMA
@@ -350,9 +349,8 @@ namespace boost {
           typedef functor_manager<FunctionPtr> manager_type;
         };
 
-        template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename FunctionPtr, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
@@ -385,9 +383,8 @@ namespace boost {
           typedef functor_manager<MemberPtr> manager_type;
         };
 
-        template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename MemberPtr, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
@@ -420,9 +417,8 @@ namespace boost {
           typedef functor_manager<FunctionObj> manager_type;
         };
 
-        template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename FunctionObj, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
@@ -454,9 +450,8 @@ namespace boost {
           typedef reference_manager<typename RefWrapper::type> manager_type;
         };
 
-        template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename RefWrapper, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
@@ -567,27 +562,27 @@ namespace boost {
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
         {
           new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
         {
-          assign_functor(f,functor,mpl::true_());
+          assign_functor(f,functor,true_type());
         }
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
         {
           functor.members.obj_ptr = new FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
@@ -615,7 +610,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor(f, functor,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -627,7 +622,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor_a(f, functor, a,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -708,14 +703,14 @@ namespace boost {
 
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base() { }
+    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
     template<typename Functor>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,typename boost::enable_if_<
                              !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -727,7 +722,7 @@ namespace boost {
     template<typename Functor,typename Allocator>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_c<
+                            ,typename boost::enable_if_<
                               !(is_integral<Functor>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
@@ -776,7 +771,7 @@ namespace boost {
     // construct.
     template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-    typename boost::enable_if_c<
+    typename boost::enable_if_<
                   !(is_integral<Functor>::value),
                BOOST_FUNCTION_FUNCTION&>::type
 #else
@@ -903,9 +898,24 @@ namespace boost {
     {
       if (!f.empty()) {
         this->vtable = f.vtable;
-        if (this->has_trivial_copy_and_destroy())
-          this->functor = f.functor;
-        else
+        if (this->has_trivial_copy_and_destroy()) {
+          // Don't operate on storage directly since union type doesn't relax
+          // strict aliasing rules, despite of having member char type.
+#         if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
+#           pragma GCC diagnostic push
+            // This warning is technically correct, but we don't want to pay the price for initializing
+            // just to silence a warning: https://github.com/boostorg/function/issues/27
+#           pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#           if (BOOST_GCC >= 120000)
+              // GCC 12 emits a different warning: https://github.com/boostorg/function/issues/42
+#             pragma GCC diagnostic ignored "-Wuninitialized"
+#           endif
+#         endif
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+#         if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
+#           pragma GCC diagnostic pop
+#         endif
+        } else
           get_vtable()->base.manager(f.functor, this->functor,
                                      boost::detail::function::clone_functor_tag);
       }
@@ -953,9 +963,8 @@ namespace boost {
       typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
       typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply_a<Functor, R BOOST_FUNCTION_COMMA
-                         BOOST_FUNCTION_TEMPLATE_ARGS,
-                         Allocator>
+                         template apply_a<Functor, Allocator, R BOOST_FUNCTION_COMMA
+                         BOOST_FUNCTION_TEMPLATE_ARGS>
         handler_type;
 
       typedef typename handler_type::invoker_type invoker_type;
@@ -991,11 +1000,34 @@ namespace boost {
       BOOST_TRY {
         if (!f.empty()) {
           this->vtable = f.vtable;
-          if (this->has_trivial_copy_and_destroy())
-            this->functor = f.functor;
-          else
+          if (this->has_trivial_copy_and_destroy()) {
+            // Don't operate on storage directly since union type doesn't relax
+            // strict aliasing rules, despite of having member char type.
+#           if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
+#             pragma GCC diagnostic push
+              // This warning is technically correct, but we don't want to pay the price for initializing
+              // just to silence a warning: https://github.com/boostorg/function/issues/27
+#             pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#             if (BOOST_GCC >= 120000)
+                // GCC 12 emits a different warning: https://github.com/boostorg/function/issues/42
+#               pragma GCC diagnostic ignored "-Wuninitialized"
+#             endif
+#           endif
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+#           if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
+#             pragma GCC diagnostic pop
+#           endif
+          } else
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic push
+// False positive in GCC 11/12 for empty function objects (function_n_test.cpp:673)
+# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
             get_vtable()->base.manager(f.functor, this->functor,
                                      boost::detail::function::move_functor_tag);
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic pop
+#endif
           f.vtable = 0;
         } else {
           clear();
@@ -1042,7 +1074,7 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
 #else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
 #endif
 
 template<typename R BOOST_FUNCTION_COMMA
@@ -1057,12 +1089,12 @@ class function<BOOST_FUNCTION_PARTIAL_SPEC>
 
 public:
 
-  function() : base_type() {}
+  BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})
 
   template<typename Functor>
   function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,typename boost::enable_if_<
                           !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
@@ -1073,7 +1105,7 @@ public:
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_c<
+           ,typename boost::enable_if_<
                            !(is_integral<Functor>::value),
                        int>::type = 0
 #endif
@@ -1112,7 +1144,7 @@ public:
 
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-  typename boost::enable_if_c<
+  typename boost::enable_if_<
                          !(is_integral<Functor>::value),
                       self_type&>::type
 #else