redboltz
commented
9 years ago I analyzed a little and created a minimal code that reproduce the problem. See the following code:
#include <tuple>
#include <utility>
template<bool...> struct bool_pack;
template<bool...values> struct all_of_imp
: std::is_same<bool_pack<values..., true>, bool_pack<true, values...>> {};
template<template <class> class T, class... U>
using all_of = all_of_imp<T<U>::value...>;
template <typename T, typename Enabler = void>
struct as;
template <typename T>
struct has_as {
private:
template <typename U>
static auto check(U*) -> typename std::is_same<decltype(as<U>()()), T>::type;
template <typename>
static std::false_type check(...);
public:
using type = decltype(check<T>(nullptr));
static constexpr bool value = type::value;
};
template <typename... Args>
struct as<std::tuple<Args...>, typename std::enable_if<all_of<has_as, Args...>::value>::type> {
std::tuple<Args...> operator()() const {
return std::tuple<Args...>();
}
};
struct my {};
template <>
struct as<my> {
my operator()() const {
return my();
}
};
template <typename T, typename U>
typename std::enable_if<all_of<has_as, T, U>::value>::type foo(std::tuple<T, U> const&) {}
template <typename... Args>
typename std::enable_if<all_of<has_as, Args...>::value>::type bar(std::tuple<Args...> const&) {}
int main() {
static_assert(all_of<has_as, my, my>::value, ""); // OK
foo(std::tuple<my, my>()); // OK
bar(std::tuple<my>()); // OK
bar(std::tuple<my, my>()); // ERROR on MSVC2015
}clang++ and g++ have no compile errors. http://melpon.org/wandbox/permlink/anHrLJzwWvnLC5cn http://melpon.org/wandbox/permlink/xbYL2J8UFSlyEPZe
However, MSVC2015 produced the following compile error:
source1.cpp(55): error C2893: Failed to specialize function template 'std::enable_if<all_of_imp<has_as<Args...>::value>::value,void>::type bar(const std::tuple<_Types...> &)'
source1.cpp(55): note: With the following template arguments:
source1.cpp(55): note: 'Args={my, my}'The original problem that requires default constructor is the result of specialization failure. When the specialization failure, 'as' is fallbacked into 'convert'. 'convert' requires a default constructor.
This code reproduce the specialization failure.
I guess that there are some variadic template parameters related problems on MSVC2015. Consider the following code:
foo(std::tuple<my, my>()); // OK
bar(std::tuple<my>()); // OK
bar(std::tuple<my, my>()); // ERROR on MSVC2015foo() with two template arguments compiled successfully. foo()'s enable_if has two template parameters. bar() with one template argument compiled successfully. bar()'s enable_if has variadic template parameters.
template <typename T, typename U>
typename std::enable_if<all_of<has_as, T, U>::value>::type foo(std::tuple<T, U> const&) {}
template <typename... Args>
typename std::enable_if<all_of<has_as, Args...>::value>::type bar(std::tuple<Args...> const&) {}
See: https://github.com/msgpack/msgpack-c/pull/339#issuecomment-131367798
When the line *1 uncomment, I got the following compile error:
The error message indicates line 27:
but the line 36:
causes the compile error.
If the elements of the std::tuple is one, no errors are occurred, if the elements of the std::tuple are two or more, the compile error occurs.
This compile error only happens C++11 msgpack-c, So you can avoid the compile error with MSGPACK_USE_CPP03 macro definition.
I analyzed msgpack-c code. I think that https://github.com/msgpack/msgpack-c/blob/master/include/msgpack/adaptor/cpp11/tuple.hpp#L75 is something relate to the problem. This code works well on Linux with libstdc++ and osx with libc++. I think that MSVC2015's tuple implementation might have a problem. But I couldn't write a minimal code that reproduces the problem.
Any help is welcome.