[Bug libstdc++/103448] New: unexpected tuple collapse

[Bug libstdc++/103448] New: unexpected tuple collapse

[janezz55 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

            Bug ID: 103448
           Summary: unexpected tuple collapse
           Product: gcc
           Version: 11.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: janezz55 at gmail dot com
  Target Milestone: ---

Here you have a fully working program, that instead of creating a

std::tuple<std::tuple<int&, int&>>

creates a

std::tuple<int&, int&>

something collapses the tuple of tuples into a single tuple. The workaround is
to replace the std::tuple() constructor call with a std::make_tuple() call.

https://wandbox.org/permlink/Q5P8iaUjThDKxJL9

#include <iostream>
#include <tuple>
#include <string_view>

template <typename T>
constexpr auto type_name() {
  std::string_view name, prefix, suffix;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  prefix = "auto type_name() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  prefix = "constexpr auto type_name() [with T = ";
  suffix = "]";
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
  prefix = "auto __cdecl type_name<";
  suffix = ">(void)";
#endif
  name.remove_prefix(prefix.size());
  name.remove_suffix(suffix.size());
  return name;
}

template <std::size_t N>
constexpr auto split(auto&& t) noexcept requires(bool(N))
{
  constexpr auto n(std::tuple_size_v<std::remove_cvref_t<decltype(t)>>);
  static_assert(n && !(n % N));
  return [&]<auto ...I>(std::index_sequence<I...>) noexcept
  {
    return std::tuple(
      [&]<auto ...J>(std::index_sequence<J...>) noexcept
      {
        constexpr auto K(N * I);
        return std::forward_as_tuple(std::get<K + J>(t)...);
      }(std::make_index_sequence<N + I - I>())...
    );
  }(std::make_index_sequence<n / N>());
}

int main()
{
  auto t(split<2>(std::tuple(1, 2)));
  std::cout << type_name<decltype(t)>() << std::endl;

  return 0;
}

[Bug libstdc++/103448] unexpected tuple collapse

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Hmm, even clang with libc++ produces the same ....

[Bug libstdc++/103448] unexpected tuple collapse

[janezz55 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #2 from Janez Zemva <janezz55 at gmail dot com> ---
I have no idea, but it seems wrong me. Is there an explanation for the lvalue
references? I expected rvalue references, but that's unrelated to the bug.

[Bug libstdc++/103448] unexpected tuple collapse

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |INVALID

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
>something collapses the tuple of tuples into a single tuple. The workaround is to replace the std::tuple() constructor 

Yes it is called the copy (or move) constructor :).

[Bug libstdc++/103448] unexpected tuple collapse

[janezz55 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #4 from Janez Zemva <janezz55 at gmail dot com> ---
Ok, thank you :)

[Bug libstdc++/103448] unexpected tuple collapse

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #5 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Andrew Pinski from comment #3)
> Yes it is called the copy (or move) constructor :).

That is:
  auto t = std::tuple(std::tuple(1,2));
  std::cout << type_name<decltype(t)>() << std::endl;

Will produce the same result.

[Bug libstdc++/103448] unexpected tuple collapse

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #6 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Andrew Pinski from comment #5)
> (In reply to Andrew Pinski from comment #3)
> > Yes it is called the copy (or move) constructor :).
> 
> That is:
>   auto t = std::tuple(std::tuple(1,2));
>   std::cout << type_name<decltype(t)>() << std::endl;
> 
> Will produce the same result.

Or:

  auto t1 = std::tuple(1,2);
  auto t = std::tuple(t1);
  std::cout << type_name<decltype(t)>() << std::endl;

There is no magic going on here, just a copy constructor happening which it
looks like you forgot about.

[Bug libstdc++/103448] unexpected tuple collapse

[janezz55 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #7 from Janez Zemva <janezz55 at gmail dot com> ---
The c++17 type deduction rules are also going on. This makes me wonder how
std::make_tuple() circumvents the problem.

[Bug libstdc++/103448] unexpected tuple collapse

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Janez Zemva from comment #7)
> The c++17 type deduction rules are also going on. This makes me wonder how
> std::make_tuple() circumvents the problem.

Easy, it does not use the C++17 deduction rules at all, it is explict.

That is:
std::make_tuple is defined as:

template<typename ...T>
auto make_tuple(const T &...a)
{
  return std::tuple<T...>(a...);
}

And there is no C++17 class deduction rules going on, it is pure normal C++11
template function deduction rules.

[Bug libstdc++/103448] unexpected tuple collapse

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #9 from Jonathan Wakely <redi at gcc dot gnu.org> ---
With class template argument deduction, T(T<args...>{}) will always make a copy
of the same type, and not wrap it in a different specialization of the
template.

There is no bug here, as Andrew said.

[Bug libstdc++/103448] unexpected tuple collapse

[janezz55 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103448

--- Comment #10 from Janez Zemva <janezz55 at gmail dot com> ---
The code worked for ((...), (...), ...), but not for ((...)), I did not
understand how a tuple not containing another tuple could possibly be
constructed. On the other hand, I already found a workaround and I already
asked a question on SO and it was the folks there who advised incorrectly, that
I should construct the top tuple using std::tuple() and not std::make_tuple().
The only place remaining to write anything in was therefore here.