[to] Fix ambiguous conversion to the underlying type for integral constants

Fixes #354

Author: ldionne

include/boost/hana/core/to.hpp

@@ -39,27 +39,29 @@ BOOST_HANA_NAMESPACE_BEGIN
     namespace convert_detail {
         struct no_conversion { };
 
-        template <typename ...>
-        struct is_valid { static constexpr bool value = true; };
-    }
+        template <typename To, typename From, typename = void>
+        struct maybe_static_cast : no_conversion {
+            template <typename X>
+            static constexpr auto apply(X const&) {
+                static_assert(detail::wrong<to_impl<To, From>, X>{},
+                "no conversion is available between the provided types");
+            }
+        };
 
-    template <typename To, typename From, bool condition>
-    struct to_impl<To, From, when<condition>> : convert_detail::no_conversion {
-        template <typename X>
-        static constexpr auto apply(X const&) {
-            static_assert(detail::wrong<to_impl<To, From>, X>{},
-            "no conversion is available between the provided types");
-        }
-    };
+        template <typename To, typename From>
+        struct maybe_static_cast<To, From, decltype((void)
+            static_cast<To>(std::declval<From>())
+        )> {
+            template <typename X>
+            static constexpr To apply(X&& x)
+            { return static_cast<To>(static_cast<X&&>(x)); }
+        };
+    } // end namespace convert_detail
 
-    template <typename To, typename From>
-    struct to_impl<To, From, when<convert_detail::is_valid<
-        decltype(static_cast<To>(std::declval<From>()))
-    >::value>> {
-        template <typename X>
-        static constexpr To apply(X&& x)
-        { return static_cast<To>(static_cast<X&&>(x)); }
-    };
+    template <typename To, typename From, bool condition>
+    struct to_impl<To, From, when<condition>>
+        : convert_detail::maybe_static_cast<To, From>
+    { };
 
     template <typename To>
     struct to_impl<To, To> : embedding<> {

test/concept/constant/to.cpp

@@ -0,0 +1,21 @@
+// 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 "minimal.hpp"
+
+#include <boost/hana/concept/constant.hpp>
+#include <boost/hana/core/to.hpp>
+namespace hana = boost::hana;
+
+
+static_assert(hana::is_convertible<minimal_constant_tag<bool>, bool>::value, "");
+static_assert(hana::to<bool>(minimal_constant<bool, true>{}) == true, "");
+
+static_assert(hana::is_convertible<minimal_constant_tag<int>, int>::value, "");
+static_assert(hana::to<int>(minimal_constant<int, 1>{}) == 1, "");
+
+static_assert(hana::is_convertible<minimal_constant_tag<long>, long>::value, "");
+static_assert(hana::to<long>(minimal_constant<long, 1>{}) == 1l, "");
+
+int main() { }

test/integral_constant/github_354.cpp

@@ -0,0 +1,20 @@
+// 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/bool.hpp>
+#include <boost/hana/core/to.hpp>
+#include <boost/hana/integral_constant.hpp>
+namespace hana = boost::hana;
+
+
+static_assert(hana::is_convertible<hana::bool_<true>, bool>::value, "");
+static_assert(hana::to<bool>(hana::bool_c<true>) == true, "");
+
+static_assert(hana::is_convertible<hana::integral_constant<int, 1>, int>::value, "");
+static_assert(hana::to<int>(hana::integral_c<int, 1>) == 1, "");
+
+static_assert(hana::is_convertible<hana::integral_constant<long, 1l>, long>::value, "");
+static_assert(hana::to<long>(hana::integral_c<long, 1l>) == 1l, "");
+
+int main() { }