gcc/testsuite/g++.dg/torture/pr65914.C

   1 /* { dg-do compile } */
   2 /* { dg-additional-options "-std=c++14" } */
   3
   4 enum expression_template_option { et_on };
   5 template <class, expression_template_option = et_on> class A;
   6 template <class, class, class, class = void, class = void> struct expression;
   7 template <class T> struct B { typedef const T &type; };
   8 template <class tag, class A1, class A2, class A3, class A4>
   9 struct B<expression<tag, A1, A2, A3, A4>> {
  10   typedef expression<tag, A1, A2> type;
  11 };
  12 template <class tag, class Arg1, class Arg2>
  13 struct expression<tag, Arg1, Arg2> {
  14   expression(Arg1 p1, const Arg2 &p2) : arg1(p1), arg2(p2) {}
  15   typename B<Arg1>::type arg1;
  16   typename B<Arg2>::type arg2;
  17 };
  18 template <class Backend> expression<int, int, A<Backend>> sin(A<Backend>) {
  19   return expression<int, int, A<Backend>>(0, 0);
  20 }
  21 template <class tag, class A1, class A2, class A3, class A4>
  22 expression<int, int, expression<tag, A1, A2>>
  23   asin(expression<tag, A1, A2, A3, A4> p1) {
  24   return expression<int, int, expression<tag, A1, A2>>(0, p1);
  25 }
  26 template <class B, expression_template_option ET, class tag, class Arg1,
  27           class Arg2, class Arg3, class Arg4>
  28 expression<int, A<B>, expression<tag, Arg1, Arg2>>
  29   operator+(A<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> p2) {
  30   return expression<int, A<B>, expression<tag, Arg1, Arg2>>(0, p2);
  31 }
  32 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2,
  33           class Arg1b, class Arg2b, class Arg3b, class Arg4b>
  34 expression<int, expression<tag, Arg1, Arg2>, expression<tag2, Arg1b, Arg2b>>
  35   operator*(expression<tag, Arg1, Arg2, Arg3, Arg4> p1,
  36             expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> p2) {
  37   return expression<int, expression<tag, Arg1, Arg2>,
  38                     expression<tag2, Arg1b, Arg2b>>(p1, p2);
  39 }
  40 template <class B> expression<int, A<B>, A<B>> operator/(A<B>, A<B>) {
  41   return expression<int, A<B>, A<B>>(0, 0);
  42 }
  43 template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
  44 void operator/(expression<tag, Arg1, Arg2, Arg3, Arg4>, V);
  45 template <class, expression_template_option> class A {
  46 public:
  47   A() {}
  48   template <class V> A(V) {}
  49 };
  50 template <class T, class Policy> void jacobi_recurse(T, T, Policy) {
  51   T a, b, c;
  52   (a+asin(b/c) * sin(a)) / 0.1;
  53 }
  54 template <class T, class Policy> void jacobi_imp(T p1, Policy) {
  55   T x;
  56   jacobi_recurse(x, p1, 0);
  57 }
  58 template <class T, class U, class V, class Policy>
  59 void jacobi_elliptic(T, U, V, Policy) {
  60   jacobi_imp(static_cast<T>(0), 0);
  61 }
  62 template <class U, class T, class Policy> void jacobi_sn(U, T, Policy) {
  63   jacobi_elliptic(static_cast<T>(0), 0, 0, 0);
  64 }
  65 template <class U, class T> void jacobi_sn(U, T p2) { jacobi_sn(0, p2, 0); }
  66 template <class T> void test_extra(T) {
  67   T d;
  68   jacobi_sn(0, d);
  69 }
  70 void foo() { test_extra(A<int>()); }