1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -fsyntax-only -verify %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING 3 // RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++1z %s 4 5 6 7 // Errors 8 export class foo { }; // expected-error {{expected template}} 9 template x; // expected-error {{C++ requires a type specifier for all declarations}} \ 10 // expected-error {{does not refer}} 11 export template x; // expected-error {{expected '<' after 'template'}} 12 export template<class T> class x0; // expected-warning {{exported templates are unsupported}} 13 template < ; // expected-error {{expected template parameter}} \ 14 // expected-error{{expected ',' or '>' in template-parameter-list}} \ 15 // expected-warning {{declaration does not declare anything}} 16 template <int +> struct x1; // expected-error {{expected ',' or '>' in template-parameter-list}} 17 18 // verifies that we only walk to the ',' & still produce errors on the rest of the template parameters 19 template <int +, T> struct x2; // expected-error {{expected ',' or '>' in template-parameter-list}} \ 20 expected-error {{expected unqualified-id}} 21 template<template<int+>> struct x3; // expected-error {{expected ',' or '>' in template-parameter-list}} \ 22 expected-error {{template template parameter requires 'class' after the parameter list}} 23 template <template X> struct Err1; // expected-error {{expected '<' after 'template'}} \ 24 // expected-error{{extraneous}} 25 template <template <typename> > struct Err2; // expected-error {{template template parameter requires 'class' after the parameter list}} 26 template <template <typename> Foo> struct Err3; // expected-error {{template template parameter requires 'class' after the parameter list}} 27 28 template <template <typename> typename Foo> struct Cxx1z; 29 #if __cplusplus <= 201402L 30 // expected-warning@-2 {{extension}} 31 #endif 32 33 // Template function declarations 34 template <typename T> void foo(); 35 template <typename T, typename U> void foo(); 36 37 // Template function definitions. 38 template <typename T> void foo() { } 39 40 // Template class (forward) declarations 41 template <typename T> struct A; 42 template <typename T, typename U> struct b; 43 template <typename> struct C; 44 template <typename, typename> struct D; 45 46 // Forward declarations with default parameters? 47 template <typename T = int> class X1; 48 template <typename = int> class X2; 49 50 // Forward declarations w/template template parameters 51 template <template <typename> class T> class TTP1; 52 template <template <typename> class> class TTP2; 53 template <template <typename> class T = foo> class TTP3; // expected-error{{must be a class template}} 54 template <template <typename> class = foo> class TTP3; // expected-error{{must be a class template}} 55 template <template <typename X, typename Y> class T> class TTP5; 56 57 // Forward declarations with non-type params 58 template <int> class NTP0; 59 template <int N> class NTP1; 60 template <int N = 5> class NTP2; 61 template <int = 10> class NTP3; 62 template <unsigned int N = 12u> class NTP4; 63 template <unsigned int = 12u> class NTP5; 64 template <unsigned = 15u> class NTP6; 65 template <typename T, T Obj> class NTP7; 66 67 // Template class declarations 68 template <typename T> struct A { }; 69 template <typename T, typename U> struct B { }; 70 71 // Template parameter shadowing 72 template<typename T, // expected-note{{template parameter is declared here}} 73 typename T> // expected-error{{declaration of 'T' shadows template parameter}} 74 void shadow1(); 75 76 template<typename T> // expected-note{{template parameter is declared here}} 77 void shadow2(int T); // expected-error{{declaration of 'T' shadows template parameter}} 78 79 template<typename T> // expected-note{{template parameter is declared here}} 80 class T { // expected-error{{declaration of 'T' shadows template parameter}} 81 }; 82 83 template<int Size> // expected-note{{template parameter is declared here}} 84 void shadow3(int Size); // expected-error{{declaration of 'Size' shadows template parameter}} 85 86 // <rdar://problem/6952203> 87 template<typename T> // expected-note{{here}} 88 struct shadow4 { 89 int T; // expected-error{{shadows}} 90 }; 91 92 template<typename T> // expected-note{{here}} 93 struct shadow5 { 94 int T(int, float); // expected-error{{shadows}} 95 }; 96 97 template<typename T, // expected-note{{template parameter is declared here}} 98 T T> // expected-error{{declaration of 'T' shadows template parameter}} 99 void shadow6(); 100 101 template<typename T, // expected-note{{template parameter is declared here}} 102 template<typename> class T> // expected-error{{declaration of 'T' shadows template parameter}} 103 void shadow7(); 104 105 // PR8302 106 template<template<typename> class T> struct shadow8 { // expected-note{{template parameter is declared here}} 107 template<template<typename> class T> struct inner; // expected-error{{declaration of 'T' shadows template parameter}} 108 }; 109 110 // Non-type template parameters in scope 111 template<int Size> 112 void f(int& i) { 113 i = Size; 114 #ifdef DELAYED_TEMPLATE_PARSING 115 Size = i; 116 #else 117 Size = i; // expected-error{{expression is not assignable}} 118 #endif 119 } 120 121 template<typename T> 122 const T& min(const T&, const T&); 123 124 void f2() { 125 int x; 126 A< typeof(x>1) > a; 127 } 128 129 130 // PR3844 131 template <> struct S<int> { }; // expected-error{{explicit specialization of non-template struct 'S'}} 132 template <> union U<int> { }; // expected-error{{explicit specialization of non-template union 'U'}} 133 134 namespace PR6184 { 135 namespace N { 136 template <typename T> 137 void bar(typename T::x); 138 } 139 140 template <typename T> 141 void N::bar(typename T::x) { } 142 } 143 144 // This PR occurred only in template parsing mode. 145 namespace PR17637 { 146 template <int> 147 struct L { 148 template <typename T> 149 struct O { 150 template <typename U> 151 static void Fun(U); 152 }; 153 }; 154 155 template <int k> 156 template <typename T> 157 template <typename U> 158 void L<k>::O<T>::Fun(U) {} 159 160 void Instantiate() { L<0>::O<int>::Fun(0); } 161 162 } 163 164 namespace explicit_partial_specializations { 165 typedef char (&oneT)[1]; 166 typedef char (&twoT)[2]; 167 typedef char (&threeT)[3]; 168 typedef char (&fourT)[4]; 169 typedef char (&fiveT)[5]; 170 typedef char (&sixT)[6]; 171 172 char one[1]; 173 char two[2]; 174 char three[3]; 175 char four[4]; 176 char five[5]; 177 char six[6]; 178 179 template<bool b> struct bool_ { typedef int type; }; 180 template<> struct bool_<false> { }; 181 182 #define XCAT(x,y) x ## y 183 #define CAT(x,y) XCAT(x,y) 184 #define sassert(_b_) bool_<(_b_)>::type CAT(var, __LINE__); 185 186 187 template <int> 188 struct L { 189 template <typename T> 190 struct O { 191 template <typename U> 192 static oneT Fun(U); 193 194 }; 195 }; 196 template <int k> 197 template <typename T> 198 template <typename U> 199 oneT L<k>::O<T>::Fun(U) { return one; } 200 201 template<> 202 template<> 203 template<typename U> 204 oneT L<0>::O<char>::Fun(U) { return one; } 205 206 207 void Instantiate() { 208 sassert(sizeof(L<0>::O<int>::Fun(0)) == sizeof(one)); 209 sassert(sizeof(L<0>::O<char>::Fun(0)) == sizeof(one)); 210 } 211 212 } 213
