[Bug c++/105644] New: ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[Bug c++/105644] New: ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[namniav at gmail dot com]

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

            Bug ID: 105644
           Summary: ICE in a fold expression with a requires expression:
                    in iterative_hash_template_arg, at cp/pt.cc:1805
           Product: gcc
           Version: 12.1.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: namniav at gmail dot com
  Target Milestone: ---

https://godbolt.org/z/8qehadhbT

============
#include <concepts>
#include <type_traits>

#include <utility>
#include <tuple>

template<class T>
concept tuple_like = 
    [] <std::size_t...I> (std::index_sequence<I...>) {
        return ((requires(T t) {
                    { get<I>(t) } ->
std::convertible_to<std::tuple_element_t<I, T>&>;
                }) && ...);
    } (std::make_index_sequence<std::tuple_size_v<T>>{});

static_assert(tuple_like<std::tuple<int>>);
============

Both 12.1 and current trunk version on godbolt.org crashed.
There's no issue if `std::tuple_element_t<I, T>&` is replaced with `int&`.


Compiler output:
<source>: In instantiation of '<lambda(std::index_sequence<I ...>)> [with long
unsigned int ...I = {0}; std::index_sequence<I ...> =
std::integer_sequence<long unsigned int, 0>]':
<source>:13:7:   required from here
<source>:11:23: internal compiler error: in iterative_hash_template_arg, at
cp/pt.cc:1805
   11 |                     { get<I>(t) } ->
std::convertible_to<std::tuple_element_t<I, T>&>;
      |                    
~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
0x2204919 internal_error(char const*, ...)
        ???:0
0x744dd3 fancy_abort(char const*, int, char const*)
        ???:0
0x99a843 iterative_hash_template_arg(tree_node*, unsigned int)
        ???:0
0x7da898 sat_hasher::hash(sat_entry*)
        ???:0
0x7d52c7 satisfaction_cache::satisfaction_cache(tree_node*, tree_node*,
sat_info)
        ???:0
0x7d9c2a constraints_satisfied_p(tree_node*, tree_node*)
        ???:0
0x9b3ffe do_auto_deduction(tree_node*, tree_node*, tree_node*, int,
auto_deduction_context, tree_node*, int)
        ???:0
0x7d7ce2 tsubst_requires_expr(tree_node*, tree_node*, int, tree_node*)
        ???:0
0x9dd888 tsubst_pack_expansion(tree_node*, tree_node*, int, tree_node*)
        ???:0
0x9c8517 instantiate_decl(tree_node*, bool, bool)
        ???:0
0x864c7e maybe_instantiate_decl(tree_node*)
        ???:0
0x866758 mark_used(tree_node*, int)
        ???:0
0x77a52b build_op_call(tree_node*, vec<tree_node*, va_gc, vl_embed>**, int)
        ???:0
0xa31a87 finish_call_expr(tree_node*, vec<tree_node*, va_gc, vl_embed>**, bool,
bool, int)
        ???:0
0x7d9c88 evaluate_concept_check(tree_node*)
        ???:0
0x7c50ec maybe_constant_value(tree_node*, tree_node*, bool)
        ???:0
0xa3dafd finish_static_assert(tree_node*, tree_node*, unsigned int, bool, bool)
        ???:0
0x98c15d c_parse_file()
        ???:0
0xb20141 c_common_parse_file()
        ???:0
```

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[marxin at gcc dot gnu.org]

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

Martin Liška <marxin at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2022-05-18
                 CC|                            |marxin at gcc dot gnu.org,
                   |                            |ppalka at gcc dot gnu.org

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[marxin at gcc dot gnu.org]

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

--- Comment #1 from Martin Liška <marxin at gcc dot gnu.org> ---
The original code is valid (accepted) by clang. But it's hard to reduce it as
clang++ does not accept's gcc's -E output and vice versa :/

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Assignee|unassigned at gcc dot gnu.org      |ppalka at gcc dot gnu.org
             Status|NEW                         |ASSIGNED

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[namniav at gmail dot com]

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

--- Comment #2 from Namniav <namniav at gmail dot com> ---
Now Clang also crashes on the original
example(https://github.com/llvm/llvm-project/issues/64607), although its cause
may be different to GCC's.

I can't remember why I used `get` instead of `std::get` in original code
because I didn't really know how ADL finds function templates. The issue still
exists with `std::get`.

Here is a modified and GCC-only reduced version:
https://godbolt.org/z/MMYMrGE3z

```c++
template<typename T, int I>
concept C = (sizeof(I) + sizeof(T) > 0);

template<typename T, int...I>
constexpr bool check() {
    return ((requires(T t) {
                { (I, t) } -> C<I>;
            }) && ...);
}

template<class T>
concept tuple_like = check<T, 0>();

static_assert(tuple_like<int>);
```

Noted that GCC doesn't consider using `I` in `-> C<I>` as using a parameter
pack, I have to use it in comma expression `(I, t)` to get a fold expression,
otherwise GCC complains "operand of fold expression has no unexpanded parameter
packs". I suspect that GCC has problem with such case. It some how explains,
for GCC only, why replacing `std::tuple_element_t<I, T>&` with `int&` "fixes"
the issue.

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|needs-reduction             |

--- Comment #3 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Thanks for the reduction. Fixing this GCC bug(s) proved to be tricky, but one
should be able to reliably work around it by avoiding using a requires-expr
directly inside a pack expansion or fold expression and use it indirectly
instead, e.g.

template<class T, int I>
concept foo = requires(T t) { { (I, t) } -> C<I>; };

template<typename T, int...I>
constexpr bool check() {
    return (foo<T, I> && ...);
}

[Bug c++/105644] ICE in a fold expression with a requires expression: in iterative_hash_template_arg, at cp/pt.cc:1805

[mpolacek at gcc dot gnu.org]

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

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |hlewin at gmx dot de

--- Comment #4 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
*** Bug 115075 has been marked as a duplicate of this bug. ***