From 150cb8dcbd2868a2f64305c60e05216a5c60b689 Mon Sep 17 00:00:00 2001
From: Gennaro Prota <gennaro.prota@gmail.com>
Date: Thu, 13 Aug 2026 17:24:07 +0200
Subject: [PATCH] Deprecate std_variant.hpp and remove variant2.hpp

Support for `boost::variant`, `boost::variant2::variant` and
`std::variant` has moved to variant.hpp.

std_variant.hpp still compiled on its own, so it stays as a deprecated
forwarding header.

variant2.hpp could not have a working user: it declared a partial
specialization whose argument list is identical to the primary template,
which is ill-formed.  It has been that way since 897dec4c, the commit
which gave `variant.hpp` its own variant2 support. So we remove it.
---
 include/boost/serialization/std_variant.hpp | 191 +-------------------
 include/boost/serialization/variant2.hpp    | 174 ------------------
 test/Jamfile.v2                             |   1 +
 test/test_std_variant_forwarding.cpp        |  39 ++++
 4 files changed, 50 insertions(+), 355 deletions(-)
 delete mode 100644 include/boost/serialization/variant2.hpp
 create mode 100644 test/test_std_variant_forwarding.cpp

diff --git a/include/boost/serialization/std_variant.hpp b/include/boost/serialization/std_variant.hpp
index 8d38c8f07..0b54e0e78 100644
--- a/include/boost/serialization/std_variant.hpp
+++ b/include/boost/serialization/std_variant.hpp
@@ -7,7 +7,7 @@
 #endif
 
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// variant.hpp - non-intrusive serialization of variant types
+// std_variant.hpp - deprecated, forwards to variant.hpp
 //
 // copyright (c) 2019 Samuel Debionne, ESRF
 //
@@ -17,188 +17,17 @@
 //
 // See http://www.boost.org for updates, documentation, and revision history.
 //
-// Widely inspired form boost::variant serialization
-//
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <variant>
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class Archive>
-struct std_variant_save_visitor
-{
-    std_variant_save_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T const & value) const
-    {
-        m_ar << BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-
-template<class Archive>
-struct std_variant_load_visitor
-{
-    std_variant_load_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T & value) const
-    {
-        m_ar >> BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-template<class Archive, class ...Types>
-void save(
-    Archive & ar,
-    std::variant<Types...> const & v,
-    unsigned int /*version*/
-){
-    const std::size_t which = v.index();
-    ar << BOOST_SERIALIZATION_NVP(which);
-    std_variant_save_visitor<Archive> visitor(ar);
-    std::visit(visitor, v);
-}
-
-// Minimalist metaprogramming for handling parameter pack
-namespace mp {
-    namespace detail {
-    template <typename Seq>
-    struct front_impl;
-
-    template <template <typename...> class Seq, typename T, typename... Ts>
-    struct front_impl<Seq<T, Ts...>> {
-        using type = T;
-    };
-
-    template <typename Seq>
-    struct pop_front_impl;
-
-    template <template <typename...> class Seq, typename T, typename... Ts>
-    struct pop_front_impl<Seq<T, Ts...>> {
-        using type = Seq<Ts...>;
-    };
-    } //namespace detail
-
-    template <typename... Ts>
-    struct typelist {};
-
-    template <typename Seq>
-    using front = typename detail::front_impl<Seq>::type;
-
-    template <typename Seq>
-    using pop_front = typename detail::pop_front_impl<Seq>::type;
-}  // namespace mp
-
-template<std::size_t N, class Seq>
-struct variant_impl
-{
-    template<class Archive, class V>
-    static void load (
-        Archive & ar,
-        std::size_t which,
-        V & v,
-        const unsigned int version
-    ){
-        if(which == 0){
-            // note: A non-intrusive implementation (such as this one)
-            // necessary has to copy the value.  This wouldn't be necessary
-            // with an implementation that de-serialized to the address of the
-            // aligned storage included in the variant.
-            using type = mp::front<Seq>;
-            type value;
-            ar >> BOOST_SERIALIZATION_NVP(value);
-            v = std::move(value);
-            type * new_address = & std::get<type>(v);
-            ar.reset_object_address(new_address, & value);
-            return;
-        }
-        //typedef typename mpl::pop_front<S>::type type;
-        using types = mp::pop_front<Seq>;
-        variant_impl<N - 1, types>::load(ar, which - 1, v, version);
-    }
-};
-
-template<class Seq>
-struct variant_impl<0, Seq>
-{
-    template<class Archive, class V>
-    static void load (
-        Archive & /*ar*/,
-        std::size_t /*which*/,
-        V & /*v*/,
-        const unsigned int /*version*/
-    ){}
-};
-
-template<class Archive, class... Types>
-void load(
-    Archive & ar, 
-    std::variant<Types...>& v,
-    const unsigned int version
-){
-    std::size_t which;
-    ar >> BOOST_SERIALIZATION_NVP(which);
-    if(which >=  sizeof...(Types))
-        // this might happen if a type was removed from the list of variant types
-        boost::serialization::throw_exception(
-            boost::archive::archive_exception(
-                boost::archive::archive_exception::unsupported_version
-            )
-        );
-    variant_impl<sizeof...(Types), mp::typelist<Types...>>::load(ar, which, v, version);
-}
-
-template<class Archive,class... Types>
-inline void serialize(
-    Archive & ar,
-    std::variant<Types...> & v,
-    const unsigned int file_version
-){
-    split_free(ar,v,file_version);
-}
-
-// Specialization for std::monostate
-template<class Archive>
-void serialize(Archive &, std::monostate &, const unsigned int /*version*/)
-{}
-
-} // namespace serialization
-} // namespace boost
 
-//template<typename T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)>
+// variant.hpp serializes std::variant, next to boost::variant and
+// boost::variant2::variant, and defines the same save, load and serialize
+// this header used to, so the two could not both be included.  Nothing is
+// left here but the forwarding, which keeps code including this header
+// working and lets it include variant.hpp as well.
 
-#include <boost/serialization/tracking.hpp>
+#include <boost/config/header_deprecated.hpp>
 
-namespace boost {
-    namespace serialization {
-        
-template<class... Types>
-struct tracking_level<
-    std::variant<Types...>
->{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_< ::boost::serialization::track_always> type;
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
+BOOST_HEADER_DEPRECATED("<boost/serialization/variant.hpp>")
 
-} // namespace serialization
-} // namespace boost
+#include <boost/serialization/variant.hpp>
 
-#endif //BOOST_SERIALIZATION_VARIANT_HPP
+#endif // BOOST_SERIALIZATION_STD_VARIANT_HPP
diff --git a/include/boost/serialization/variant2.hpp b/include/boost/serialization/variant2.hpp
deleted file mode 100644
index 2bcbcf737..000000000
--- a/include/boost/serialization/variant2.hpp
+++ /dev/null
@@ -1,174 +0,0 @@
-#ifndef BOOST_SERIALIZATION_VARIANT2_HPP
-#define BOOST_SERIALIZATION_VARIANT2_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// variant2.hpp - non-intrusive serialization of variant types
-//
-// copyright (c) 2019 Samuel Debionne, ESRF
-//
-// 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)
-//
-// See http://www.boost.org for updates, documentation, and revision history.
-//
-// Widely inspired from boost::variant serialization
-//
-
-#include <boost/serialization/throw_exception.hpp>
-
-#include <boost/archive/archive_exception.hpp>
-
-#include <boost/mp11/list.hpp>
-
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/serialization.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class Archive>
-struct variant2_save_visitor
-{
-    variant2_save_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T const & value) const
-    {
-        m_ar << BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-
-template<class Archive>
-struct variant2_load_visitor
-{
-    variant2_load_visitor(Archive& ar) :
-        m_ar(ar)
-    {}
-    template<class T>
-    void operator()(T & value) const
-    {
-        m_ar >> BOOST_SERIALIZATION_NVP(value);
-    }
-private:
-    Archive & m_ar;
-};
-
-template<class Archive, class ...Types>
-void save(
-    Archive & ar,
-    variant2::variant<Types...> const & v,
-    unsigned int /*version*/
-){
-    const std::size_t which = v.index();
-    ar << BOOST_SERIALIZATION_NVP(which);
-    variant2_save_visitor<Archive> visitor(ar);
-    std::visit(visitor, v);
-}
-
-template<class Seq>
-struct variant_impl
-{
-    template<class Archive, class V>
-    static void load (
-        Archive & ar,
-        std::size_t which,
-        V & v,
-        const unsigned int version
-    ){
-        if(which == 0){
-            // note: A non-intrusive implementation (such as this one)
-            // necessary has to copy the value.  This wouldn't be necessary
-            // with an implementation that de-serialized to the address of the
-            // aligned storage included in the variant.
-            using type = mp11::mp_front<Seq>;
-            type value;
-            ar >> BOOST_SERIALIZATION_NVP(value);
-            v = std::move(value);
-            type * new_address = & variant2::get<type>(v);
-            ar.reset_object_address(new_address, & value);
-            return;
-        }
-        //typedef typename mpl::pop_front<S>::type type;
-        using types = mp11::mp_pop_front<Seq>;
-        variant_impl<types>::load(ar, which - 1, v, version);
-    }
-};
-
-template<class Seq>
-struct variant_impl<Seq>
-{
-    template<class Archive, class V>
-    static void load (
-        Archive & /*ar*/,
-        std::size_t /*which*/,
-        V & /*v*/,
-        const unsigned int /*version*/
-    ){}
-};
-
-template<class Archive, class... Types>
-void load(
-    Archive & ar, 
-    variant2::variant<Types...> & v,
-    const unsigned int version
-){
-    std::size_t which;
-    ar >> BOOST_SERIALIZATION_NVP(which);
-    if(which >=  sizeof...(Types))
-        // this might happen if a type was removed from the list of variant types
-        boost::serialization::throw_exception(
-            boost::archive::archive_exception(
-                boost::archive::archive_exception::unsupported_version
-            )
-        );
-    variant_impl<sizeof...(Types), mp11::mp_list<Types...>>::load(ar, which, v, version);
-}
-
-template<class Archive,class... Types>
-inline void serialize(
-    Archive & ar,
-    variant2::variant<Types...> & v,
-    const unsigned int file_version
-){
-    split_free(ar,v,file_version);
-}
-
-// Specialization for std::monostate
-template<class Archive>
-void serialize(Archive &ar, variant2::monostate &, const unsigned int /*version*/)
-{}
-
-} // namespace serialization
-} // namespace boost
-
-//template<typename T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)>
-
-#include <boost/serialization/tracking.hpp>
-
-namespace boost {
-    namespace serialization {
-        
-template<class... Types>
-struct tracking_level<
-    variant2::variant<Types...>
->{
-    typedef mpl::integral_c_tag tag;
-    typedef mpl::int_< ::boost::serialization::track_always> type;
-    BOOST_STATIC_CONSTANT(int, value = type::value);
-};
-
-} // namespace serialization
-} // namespace boost
-
-#endif //BOOST_SERIALIZATION_VARIANT2_HPP
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 97f0afee0..c0c7d7111 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -139,6 +139,7 @@ test-suite "serialization" :
 
      # should compile
      [ compile test_public_base_type.cpp ]
+     [ compile test_std_variant_forwarding.cpp ]
      [ compile test_strong_typedef.cpp ]
     ;
 
diff --git a/test/test_std_variant_forwarding.cpp b/test/test_std_variant_forwarding.cpp
new file mode 100644
index 000000000..13c48bfc3
--- /dev/null
+++ b/test/test_std_variant_forwarding.cpp
@@ -0,0 +1,39 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_std_variant_forwarding.cpp
+
+// Copyright 2026 Gennaro Prota.
+// 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// std_variant.hpp is deprecated and does nothing but include variant.hpp.
+// Code which includes it has to keep working, and, unlike before, has to be
+// able to include variant.hpp as well: the two used to define the same
+// save, load and serialize, so including both was an error.
+
+// The deprecation message is silenced here only to keep it out of the test
+// output.  Its absence is not what is being checked.
+#define BOOST_ALLOW_DEPRECATED_HEADERS
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_CXX17_HDR_VARIANT
+#include <variant>
+#endif
+
+#include <boost/serialization/std_variant.hpp>
+#include <boost/serialization/variant.hpp>
+
+#include <boost/archive/text_oarchive.hpp>
+
+int main(){
+    #ifndef BOOST_NO_CXX17_HDR_VARIANT
+    // reaching the serialization of std::variant through the deprecated
+    // header is the point of it still being there
+    const std::variant<int, char> v(1);
+    (void) v;
+    #endif
+    return 0;
+}