1 // RUN: %clang_cc1 -std=c++1z -verify -pedantic-errors %s 2 3 // Check that we deal with cases where the instantiation of a class template 4 // recursively requires the instantiation of the same template. 5 namespace test1 { 6 template<typename T> struct A { 7 struct B { // expected-note {{not complete until the closing '}'}} 8 B b; // expected-error {{has incomplete type 'test1::A<int>::B'}} 9 }; 10 B b; // expected-note {{in instantiation of}} 11 }; 12 A<int> a; // expected-note {{in instantiation of}} 13 } 14 15 namespace test2 { 16 template<typename T> struct A { 17 struct B { 18 struct C {}; 19 char c[1 + C()]; // expected-error {{invalid operands to binary expression}} operator +test2::A20 friend constexpr int operator+(int, C) { return 4; } 21 }; 22 B b; // expected-note {{in instantiation of}} 23 }; 24 A<int> a; // expected-note {{in instantiation of}} 25 } 26 27 namespace test3 { 28 // PR12317 29 template<typename T> struct A { 30 struct B { 31 enum { Val = 1 }; 32 char c[1 + Val]; // ok 33 }; 34 B b; 35 }; 36 A<int> a; 37 } 38 39 namespace test4 { 40 template<typename T> struct M { typedef int type; }; 41 template<typename T> struct A { 42 struct B { // expected-note {{not complete until the closing '}'}} 43 int k[typename A<typename M<T>::type>::B().k[0] + 1]; // expected-error {{incomplete type}} 44 }; 45 B b; // expected-note {{in instantiation of}} 46 }; 47 A<int> a; // expected-note {{in instantiation of}} 48 } 49 50 // PR12298: Recursive constexpr function template instantiation leads to 51 // stack overflow. 52 namespace test5 { 53 template<typename T> struct A { ftest5::A54 constexpr T f(T k) { return g(k); } gtest5::A55 constexpr T g(T k) { 56 return k ? f(k-1)+1 : 0; 57 } 58 }; 59 constexpr int x = A<int>().f(5); // ok 60 } 61 62 namespace test6 { 63 template<typename T> constexpr T f(T); g(T t)64 template<typename T> constexpr T g(T t) { 65 typedef int arr[f(T())]; // expected-error {{variable length array}} 66 return t; 67 } f(T t)68 template<typename T> constexpr T f(T t) { 69 typedef int arr[g(T())]; // expected-error {{zero size array}} expected-note {{instantiation of}} 70 return t; 71 } 72 int n = f(0); // expected-note 2{{instantiation of}} 73 } 74 75 namespace test7 { g(T t)76 template<typename T> constexpr T g(T t) { 77 return t; 78 } f(T t)79 template<typename T> constexpr T f(T t) { 80 typedef int arr[g(T() + 1)]; 81 return t; 82 } 83 int n = f(0); 84 } 85 86 namespace test8 { 87 template<typename T> struct A { 88 int n = A{}.n; // expected-error {{default member initializer for 'n' uses itself}} expected-note {{instantiation of default member init}} 89 }; 90 A<int> ai = {}; // expected-note {{instantiation of default member init}} 91 } 92 93 namespace test9 { 94 template<typename T> struct A { enum class B; }; 95 // FIXME: It'd be nice to give the "it has not yet been instantiated" diagnostic here. 96 template<typename T> enum class A<T>::B { k = A<T>::B::k2, k2 = k }; // expected-error {{no member named 'k2'}} 97 auto k = A<int>::B::k; // expected-note {{in instantiation of}} 98 } 99 100 namespace test10 { 101 template<typename T> struct A { 102 void f() noexcept(noexcept(f())); // expected-error {{exception specification of 'f' uses itself}} expected-note {{instantiation of}} 103 }; 104 bool b = noexcept(A<int>().f()); // expected-note {{instantiation of}} 105 } 106 107 namespace test11 { 108 template<typename T> const int var = var<T>; 109 int k = var<int>; 110 111 template<typename T> struct X { 112 static const int k = X<T>::k; 113 }; 114 template<typename T> const int X<T>::k; 115 int q = X<int>::k; 116 117 template<typename T> struct Y { 118 static const int k; 119 }; 120 template<typename T> const int Y<T>::k = Y<T>::k; 121 int r = Y<int>::k; 122 } 123 124 namespace test12 { f(T t,int=f (T ()))125 template<typename T> int f(T t, int = f(T())) {} // expected-error {{recursive evaluation of default argument}} expected-note {{instantiation of}} 126 struct X {}; 127 int q = f(X()); // expected-note {{instantiation of}} 128 } 129 130 namespace test13 { 131 struct A { 132 // Cycle via type of non-type template parameter. 133 template<typename T, typename T::template W<T>::type U = 0> struct W { using type = int; }; 134 // Cycle via default template argument. 135 template<typename T, typename U = typename T::template X<T>> struct X {}; 136 template<typename T, int U = T::template Y<T>::value> struct Y { static const int value = 0; }; 137 template<typename T, template<typename> typename U = T::template Z<T>::template nested> struct Z { template<typename> struct nested; }; 138 }; 139 template<typename T> struct Wrap { 140 template<typename U> struct W : A::W<T> {}; 141 template<typename U> struct X : A::X<T> {}; 142 template<typename U> struct Y : A::Y<T> {}; 143 template<typename U> struct Z : A::Z<T> {}; 144 }; 145 struct B { 146 template<typename U> struct W { using type = int; }; 147 template<typename U> struct X {}; 148 template<typename U> struct Y { static const int value = 0; }; 149 template<typename U> struct Z { template<typename> struct nested; }; 150 }; 151 152 A::W<B> awb; 153 A::X<B> axb; 154 A::Y<B> ayb; 155 A::Z<B> azb; 156 157 A::W<Wrap<Wrap<B>>> awwwb; 158 A::X<Wrap<Wrap<B>>> axwwb; 159 A::Y<Wrap<Wrap<B>>> aywwb; 160 A::Z<Wrap<Wrap<B>>> azwwb; 161 162 // FIXME: These tests cause us to use too much stack and crash on a self-hosted debug build. 163 // FIXME: Check for recursion here and give a better diagnostic. 164 #if 0 165 A::W<A> awa; 166 A::X<A> axa; 167 A::Y<A> aya; 168 A::Z<A> aza; 169 #endif 170 } 171