https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90227
Jakub Jelinek <jakub at gcc dot gnu.org> changed:
What |Removed |Added
----------------------------------------------------------------------------
Keywords| |rejects-valid
Priority|P3 |P1
Status|UNCONFIRMED |NEW
Last reconfirmed| |2019-04-24
Ever confirmed|0 |1
--- Comment #1 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Ah, unfortunately the originally submitted preprocessed source has been
hand-edited and so clang++ rejected it while g++ 8 still accepted it, I bet in
the category of what can but doesn't have to be diagnosed in uninstantiated
templates. I've hand-edited that back from original polymake sources so that
it compiled with clang++ and creduced again, verifying that it compiles without
errors with g++ 8 as well as clang++ and is rejected by g++ trunk this way.
The result is -std=c++14:
template <int b> struct c { static constexpr int d = b; typedef c e; };
template <bool, typename a> using f = a;
template <bool g> using h = c<g>;
template <int g> using i = c<g>;
template <typename...> struct ab {};
template <typename... j> struct k { using e = ab<j...>; };
template <typename> struct ad;
template <typename j, typename... l> struct ad<ab<j, l...>> { using e =
ab<l...>; };
template <typename> struct ae;
template <typename... m> struct ae<ab<m...>> : i<sizeof...(m)> {};
template <typename af, int, int = ae<af>::d> struct ag;
template <typename... m> struct ag<ab<m...>, 0, 0> { using e = ab<>; };
template <typename... m, int ah>
struct ag<ab<m...>, 0, ah> : k<typename ag<typename ad<ab<m...>>::e, ah -
1>::e> {};
template <typename... m, int ai, int ah>
struct ag<ab<m...>, ai, ah> : ag<typename ad<ab<m...>>::e, ai - 1> {};
template <typename, template <typename> class> struct aj;
template <typename... j, template <typename> class ak> struct aj<ab<j...>, ak>
{
using e = ab<typename ak<j>::e...>;
};
template <unsigned long> struct an;
struct ao { typedef an<0> ap; };
template <typename a, a...> struct aq {};
template <typename, typename = ao::ap> struct as;
template <typename a, unsigned long... at> struct as<a, an<at...>> { typedef
aq<a> ap; };
template <typename a, a> using au = typename as<a>::ap;
template <long... at> using av = aq<unsigned long, at...>;
template <long ar> using aw = au<unsigned long, ar>;
struct ay { using e = h<c<false>::d>; };
template <typename, template <typename> class, typename...>
struct bb : ay::e {};
struct bd { using e = av<>; };
struct bg { using e = bd::e; };
namespace bi {
enum bj { bk };
struct bo { enum n { bp }; };
struct bq { bool br; static const bo::n bs = bo::bp; };
template <typename bv> struct bw { using e = bv; };
template <typename, bj, int, typename...> class bx;
template <typename bv, bj by, int bz, typename... j, long... anchors>
struct bx<bv, by, bz, ab<j...>, av<anchors...>> : bo {
static const n bs = bv::bs;
static const long ca = sizeof bv::br;
using cb = int;
using cc = ab<j...>;
using cd = typename ag<cc, bz>::e;
using ce = typename ag<cc, bz>::e;
using cf = aw<ca>;
using cg = typename bw<bv>::e;
using ch = decltype(cg()(cb(), cd(), ce(), cf()));
};
class ck;
template <typename> struct cl : c<false> {};
template <typename bv, bj by, int bz, typename... j>
struct bx<bv, by, bz, ab<j...>> : public bx<bv, by, bz, typename aj<ab<j...>,
cl>::e, bg::e> {};
}
using bi::bj;
using bi::ck;
template <typename cn> class co {
template <typename p> co(p) { c<cn::bs>(); }
static co o;
};
namespace bi {
template <typename> class cp;
template <typename j> using cq = bb<j, cp>;
template <typename, typename cr> void cs(cr, f<cq<cr>::d, void *> = nullptr);
}
using bi::cs;
struct cu : bi::bq {
template <typename... cw, typename... cx>
auto operator()(int q, ab<cw...>, ab<cx...>, av<>) {
cs<cw...>(q);
}
};
template <>
co<bi::bx<cu, bj::bk, 1, ab<int, ck>>>
co<bi::bx<cu, bj::bk, 1, ab<int, ck>>>::o(0);
