[Bug c++/68434] [concepts] ICE: same canonical type node for different types

["trippels at gcc dot gnu.org" <gcc-bugzilla at gcc dot gnu dot org>]

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

Markus Trippelsdorf <trippels at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |trippels at gcc dot gnu.org

--- Comment #3 from Markus Trippelsdorf <trippels at gcc dot gnu.org> ---
I hit the issue today when compiling the cmcstl2 lib.
It might even be caused by Jason's patch:


markus@x4 test % cat meta.ii
namespace std {
typedef int size_t;
template <typename _Tp, _Tp __v> struct A {
  static constexpr _Tp value = __v;
  typedef _Tp value_type;
};
typedef A<bool, true> true_type;
template <bool, typename, typename> struct conditional;
struct B : true_type {};
template <typename> struct is_integral : B {};
template <typename, typename> struct is_same : true_type {};
template <typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse> {
  typedef _Iffalse type;
};
}
template <typename...> struct list;
template <template <typename...> class> struct quote;
namespace detail {
template <typename> bool _is_list;
template <typename Ts> constexpr bool _is_list<list<Ts>> = true;
}
template <typename T, typename U> concept bool Same = std::is_same<T,
U>::value;
template <typename T> concept bool Trait = requires { typename T; };
template <typename T> concept bool AliasClass = requires {
  typename quote<T::template apply>;
};
template <typename T> concept bool List = detail::_is_list<T>;
template <typename T>
concept bool Integral = requires{{T()}->Same<typename T::value_type>};
template <typename> struct id;
template <AliasClass...> struct compose;
template <Trait T> using _t = typename T::type;
template <class T> constexpr typename T::value_type _v = T::value;
template <long N> using size_t = std::A<long, N>;
template <bool B> using bool_ = std::A<bool, B>;
template <AliasClass Fn, typename... Args>
using apply = typename Fn::template apply<Args...>;
namespace detail {
template <template <typename...> class C, typename... Ts> struct defer_ {
  using type = C<Ts...>;
};
}
template <template <typename...> class C, typename... Ts>
struct defer : detail::defer_<C, Ts...> {};
template <AliasClass Fn0> struct compose<Fn0> {
  template <typename... Ts> using apply = apply<Fn0, Ts...>;
};
template <AliasClass Fn0, AliasClass... Fns> struct compose<Fn0, Fns...> {
  template <typename... Ts>
  using apply = apply<Fn0, apply<compose<Fns...>, Ts...>>;
};
template <template <typename...> class C> struct quote {
  template <typename... Ts> using apply = _t<defer<C, Ts...>>;
};
namespace detail {
template <typename...> struct _if_;
template <Integral If, typename Then, typename Else>
struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else> {};
}
template <typename... Args> using if_ = _t<detail::_if_<Args...>>;
template <bool B> using not_c = bool_<!B>;
template <Integral B> using not_ = not_c<_v<B>>;
template <typename... Ts> struct list {
  static constexpr std::size_t size() { return sizeof...(Ts); }
};
template <List L> using size = size_t<L::size()>;
template <List L> using empty = bool_<0 == _v<size<L>>>;
namespace detail {
template <typename, typename> struct find_if_ { using type = list<>; };
template <typename Head, typename... L, typename Fn>
struct find_if_<list<Head, L...>, Fn>
    : if_<apply<Fn, Head>, id<list<>>, find_if_<int, Fn>> {};
}
template <List L, AliasClass Fn> using find_if = _t<detail::find_if_<L, Fn>>;
template <AliasClass Fn> using not_fn = compose<quote<not_>, Fn>;
template <List L, AliasClass Fn> using all_of = empty<find_if<L, not_fn<Fn>>>;
static_assert(all_of<list<long>, quote<std::is_integral>>::value);


markus@x4 test % g++ -std=c++1z -c meta.ii
meta.ii: In substitution of âtemplate<class T>  requires predicate( Trait<T>)
using _t = typename T::type [with T = detail::_if_<std::A<bool, false>,
id<list<> >, detail::find_if_<int, compose<quote< requires predicate(
Integral<B>) not_>, quote<std::is_integral> > > >]â:
meta.ii:61:66:   required by substitution of âtemplate<class ... Args> using
if_ = _t<detail::_if_<Args ...> > [with Args = {apply<compose<quote< requires
predicate( Integral<B>) not_>, quote<std::is_integral> >, long int>, id<list<>
>, detail::find_if_<int, compose<quote< requires predicate( Integral<B>) not_>,
quote<std::is_integral> > >}]â
meta.ii:72:8:   required from âstruct detail::find_if_<list<long int>,
compose<quote< requires predicate( Integral<B>) not_>, quote<std::is_integral>
> >â
meta.ii:77:78:   required by substitution of âtemplate<class L, class Fn> 
requires predicate( List<L>) and predicate(AliasClass<Fn>) using all_of =
empty<typename detail::find_if_<L, compose<quote< requires predicate(
Integral<B>) not_>, Fn> >::type> [with L = list<long int>; Fn =
quote<std::is_integral>]â
meta.ii:78:56:   required from here
meta.ii:33:47: internal compiler error: same canonical type node for different
types Same<typename B::value_type> and Same<std::A<bool, false>::value_type>
 template <Trait T> using _t = typename T::type;
                                               ^

0x72fab4 comptypes(tree_node*, tree_node*, int)
        ../../gcc/gcc/cp/typeck.c:1435
0x6265af template_args_equal
        ../../gcc/gcc/cp/pt.c:7851
0x626d92 comp_template_args_with_info
        ../../gcc/gcc/cp/pt.c:7898
0x634da4 comp_template_args(tree_node*, tree_node*)
        ../../gcc/gcc/cp/pt.c:7916
0x634da4 spec_hasher::equal(spec_entry*, spec_entry*)
        ../../gcc/gcc/cp/pt.c:1642
0x68818f hash_table<spec_hasher, xcallocator>::find_with_hash(spec_entry*
const&, unsigned int)
        ../../gcc/gcc/hash-table.h:788
0x6627dd lookup_template_class_1
        ../../gcc/gcc/cp/pt.c:8297
0x6627dd lookup_template_class(tree_node*, tree_node*, tree_node*, tree_node*,
int, int)
        ../../gcc/gcc/cp/pt.c:8611
0x666c18 tsubst_aggr_type
        ../../gcc/gcc/cp/pt.c:11280
0x64f132 tsubst(tree_node*, tree_node*, int, tree_node*)
        ../../gcc/gcc/cp/pt.c:12743
0x6495ca tsubst_qualified_id
        ../../gcc/gcc/cp/pt.c:13573
0x64ae7b tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*, bool,
bool)
        ../../gcc/gcc/cp/pt.c:16028
0x640773 tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
        ../../gcc/gcc/cp/pt.c:15620
0x81deef lift_variable_initializer
        ../../gcc/gcc/cp/constraint.cc:403
0x81d6a0 normalize_predicate_constraint
        ../../gcc/gcc/cp/constraint.cc:882
0x81d6a0 normalize_constraint
        ../../gcc/gcc/cp/constraint.cc:921
0x81db6a evaluate_constraints(tree_node*, tree_node*)
        ../../gcc/gcc/cp/constraint.cc:2085
0x81dbd4 constraints_satisfied_p(tree_node*, tree_node*)
        ../../gcc/gcc/cp/constraint.cc:2169
0x63da0a do_auto_deduction(tree_node*, tree_node*, tree_node*, int,
auto_deduction_context)
        ../../gcc/gcc/cp/pt.c:23765
0x81c525 satisfy_argument_deduction_constraint
        ../../gcc/gcc/cp/constraint.cc:1903