Fix missed opportunity for EBO in nested empty basic_tuples

Also, add tests to make sure the same does not happen in hana::pair.

Author: ldionne

include/boost/hana/basic_tuple.hpp

@@ -15,6 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 #include <boost/hana/detail/decay.hpp>
 #include <boost/hana/detail/ebo.hpp>
+#include <boost/hana/detail/type_at.hpp>
 #include <boost/hana/fwd/at.hpp>
 #include <boost/hana/fwd/bool.hpp>
 #include <boost/hana/fwd/concept/sequence.hpp>
@@ -72,7 +73,7 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     //! @cond
     template <typename ...Xn>
-    struct basic_tuple final
+    struct basic_tuple
         : detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...>
     {
         using Base = detail::basic_tuple_impl<std::make_index_sequence<sizeof...(Xn)>, Xn...>;
@@ -176,28 +177,75 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     template <>
     struct at_impl<basic_tuple_tag> {
-        template <typename Xs, typename N>
-        static constexpr decltype(auto) apply(Xs&& xs, N const&) {
+        template <typename ...T, typename N>
+        static constexpr decltype(auto) apply(hana::basic_tuple<T...>& xs, N const&) {
+            constexpr std::size_t index = N::value;
+            using Nth = typename detail::type_at<index, T...>::type;
+            return detail::ebo_get<detail::bti<index>>(
+                static_cast<detail::ebo<detail::bti<index>, Nth>&>(xs)
+            );
+        }
+
+        template <typename ...T, typename N>
+        static constexpr decltype(auto) apply(hana::basic_tuple<T...>&& xs, N const&) {
             constexpr std::size_t index = N::value;
-            return detail::ebo_get<detail::bti<index>>(static_cast<Xs&&>(xs));
+            using Nth = typename detail::type_at<index, T...>::type;
+            return detail::ebo_get<detail::bti<index>>(
+                static_cast<detail::ebo<detail::bti<index>, Nth>&&>(xs)
+            );
+        }
+
+        template <typename ...T, typename N>
+        static constexpr decltype(auto) apply(hana::basic_tuple<T...> const& xs, N const&) {
+            constexpr std::size_t index = N::value;
+            using Nth = typename detail::type_at<index, T...>::type;
+            return detail::ebo_get<detail::bti<index>>(
+                static_cast<detail::ebo<detail::bti<index>, Nth> const&>(xs)
+            );
         }
     };
 
     template <>
     struct drop_front_impl<basic_tuple_tag> {
-        template <std::size_t N, typename Xs, std::size_t ...i>
-        static constexpr auto drop_front_helper(Xs&& xs, std::index_sequence<i...>) {
+        template <std::size_t N, typename ...Xs, std::size_t ...i>
+        static constexpr auto
+        drop_front_helper(hana::basic_tuple<Xs...>&& xs, std::index_sequence<i...>) {
             return hana::make_basic_tuple(
-                detail::ebo_get<detail::bti<i+N>>(static_cast<Xs&&>(xs))...
+                detail::ebo_get<detail::bti<i+N>>(
+                    static_cast<detail::ebo<
+                        detail::bti<i+N>, typename detail::type_at<i+N, Xs...>::type
+                    >&&>(xs)
+                )...
+            );
+        }
+        template <std::size_t N, typename ...Xs, std::size_t ...i>
+        static constexpr auto
+        drop_front_helper(hana::basic_tuple<Xs...>& xs, std::index_sequence<i...>) {
+            return hana::make_basic_tuple(
+                detail::ebo_get<detail::bti<i+N>>(
+                    static_cast<detail::ebo<
+                        detail::bti<i+N>, typename detail::type_at<i+N, Xs...>::type
+                    >&>(xs)
+                )...
+            );
+        }
+        template <std::size_t N, typename ...Xs, std::size_t ...i>
+        static constexpr auto
+        drop_front_helper(hana::basic_tuple<Xs...> const& xs, std::index_sequence<i...>) {
+            return hana::make_basic_tuple(
+                detail::ebo_get<detail::bti<i+N>>(
+                    static_cast<detail::ebo<
+                        detail::bti<i+N>, typename detail::type_at<i+N, Xs...>::type
+                    > const&>(xs)
+                )...
             );
         }
 
         template <typename Xs, typename N>
         static constexpr auto apply(Xs&& xs, N const&) {
             constexpr std::size_t len = detail::decay<Xs>::type::size_;
-            return drop_front_helper<N::value>(static_cast<Xs&&>(xs), std::make_index_sequence<
-                N::value < len ? len - N::value : 0
-            >{});
+            using Indices = std::make_index_sequence<N::value < len ? len - N::value : 0>;
+            return drop_front_helper<N::value>(static_cast<Xs&&>(xs), Indices{});
         }
     };
 
@@ -212,17 +260,26 @@ BOOST_HANA_NAMESPACE_BEGIN
     // compile-time optimizations (to reduce the # of function instantiations)
     template <std::size_t n, typename ...Xs>
     constexpr decltype(auto) at_c(basic_tuple<Xs...> const& xs) {
-        return detail::ebo_get<detail::bti<n>>(xs);
+        using Nth = typename detail::type_at<n, Xs...>::type;
+        return detail::ebo_get<detail::bti<n>>(
+            static_cast<detail::ebo<detail::bti<n>, Nth> const&>(xs)
+        );
     }
 
     template <std::size_t n, typename ...Xs>
     constexpr decltype(auto) at_c(basic_tuple<Xs...>& xs) {
-        return detail::ebo_get<detail::bti<n>>(xs);
+        using Nth = typename detail::type_at<n, Xs...>::type;
+        return detail::ebo_get<detail::bti<n>>(
+            static_cast<detail::ebo<detail::bti<n>, Nth>&>(xs)
+        );
     }
 
     template <std::size_t n, typename ...Xs>
     constexpr decltype(auto) at_c(basic_tuple<Xs...>&& xs) {
-        return detail::ebo_get<detail::bti<n>>(static_cast<basic_tuple<Xs...>&&>(xs));
+        using Nth = typename detail::type_at<n, Xs...>::type;
+        return detail::ebo_get<detail::bti<n>>(
+            static_cast<detail::ebo<detail::bti<n>, Nth>&&>(xs)
+        );
     }
 
     //////////////////////////////////////////////////////////////////////////

test/basic_tuple/drop_front.cpp

@@ -0,0 +1,18 @@
+// Copyright Louis Dionne 2013-2017
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/basic_tuple.hpp>
+#include <boost/hana/drop_front.hpp>
+#include <boost/hana/integral_constant.hpp>
+namespace hana = boost::hana;
+
+
+template <int i>
+struct x { };
+
+int main() {
+    // Make sure drop_front works with nested tuples
+    hana::basic_tuple<x<0>, hana::basic_tuple<x<1>, x<2>>> tuple;
+    auto all = hana::drop_front(tuple, hana::size_c<0>); (void)all;
+}

test/basic_tuple/empty_storage.cpp

@@ -0,0 +1,27 @@
+// Copyright Louis Dionne 2013-2017
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/basic_tuple.hpp>
+
+#include <type_traits>
+namespace hana = boost::hana;
+
+
+struct empty1 { };
+struct empty2 { };
+struct empty3 { };
+
+
+// Make sure the storage of a basic_tuple is compressed.
+static_assert(sizeof(hana::basic_tuple<empty1, int>) == sizeof(int), "");
+static_assert(sizeof(hana::basic_tuple<int, empty1>) == sizeof(int), "");
+
+// Also make sure that a basic_tuple with only empty members is empty. This is
+// important to ensure, for example, that a tuple of tuples of empty objects
+// will get the EBO. We also test the nested case to be sure.
+static_assert(std::is_empty<hana::basic_tuple<empty1, empty2>>{}, "");
+static_assert(std::is_empty<hana::basic_tuple<empty1, hana::basic_tuple<empty2, empty3>>>{}, "");
+
+
+int main() { }

test/pair/empty_storage.cpp

@@ -8,16 +8,20 @@
 namespace hana = boost::hana;
 
 
-// Make sure the storage of a pair is compressed
-struct empty { };
-static_assert(sizeof(hana::pair<empty, int>) == sizeof(int), "");
-static_assert(sizeof(hana::pair<int, empty>) == sizeof(int), "");
-
-// Also make sure that a pair with only empty members is empty too. This is
-// important to ensure, for example, that a tuple of pairs of empty objects
-// will get the EBO.
 struct empty1 { };
 struct empty2 { };
+struct empty3 { };
+
+
+// Make sure the storage of a pair is compressed.
+static_assert(sizeof(hana::pair<empty1, int>) == sizeof(int), "");
+static_assert(sizeof(hana::pair<int, empty1>) == sizeof(int), "");
+
+// Also make sure that a pair with only empty members is empty. This is
+// important to ensure, for example, that a tuple of pairs of empty
+// objects will get the EBO. We also test the nested case.
 static_assert(std::is_empty<hana::pair<empty1, empty2>>{}, "");
+static_assert(std::is_empty<hana::pair<empty1, hana::pair<empty2, empty3>>>{}, "");
+
 
 int main() { }