1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 // PR5057 3 namespace test0 { 4 namespace std { 5 class X { 6 public: 7 template<typename T> friend struct Y; 8 }; 9 } 10 11 namespace std { 12 template<typename T> struct Y {}; 13 } 14 } 15 16 namespace test1 { 17 template<typename T> void f1(T) { } // expected-note{{here}} 18 19 class X { 20 template<typename T> friend void f0(T); 21 template<typename T> friend void f1(T); 22 }; 23 24 template<typename T> void f0(T) { } 25 template<typename T> void f1(T) { } // expected-error{{redefinition}} 26 } 27 28 // PR4768 29 namespace test2 { 30 template<typename T> struct X0 { 31 template<typename U> friend struct X0; 32 }; 33 34 template<typename T> struct X0<T*> { 35 template<typename U> friend struct X0; 36 }; 37 38 template<> struct X0<int> { 39 template<typename U> friend struct X0; 40 }; 41 42 template<typename T> struct X1 { 43 template<typename U> friend void f2(U); 44 template<typename U> friend void f3(U); 45 }; 46 47 template<typename U> void f2(U); 48 49 X1<int> x1i; 50 X0<int*> x0ip; 51 52 template<> void f2(int); 53 54 // FIXME: Should this declaration of f3 be required for the specialization of 55 // f3<int> (further below) to work? GCC and EDG don't require it, we do... 56 template<typename U> void f3(U); 57 58 template<> void f3(int); 59 } 60 61 // PR5332 62 namespace test3 { 63 template <typename T> class Foo { 64 template <typename U> 65 friend class Foo; 66 }; 67 68 Foo<int> foo; 69 70 template<typename T, T Value> struct X2a; 71 72 template<typename T, int Size> struct X2b; 73 74 template<typename T> 75 class X3 { 76 template<typename U, U Value> friend struct X2a; 77 78 // FIXME: the redeclaration note ends up here because redeclaration 79 // lookup ends up finding the friend target from X3<int>. 80 template<typename U, T Value> friend struct X2b; // expected-error {{template non-type parameter has a different type 'long' in template redeclaration}} \ 81 // expected-note {{previous non-type template parameter with type 'int' is here}} 82 }; 83 84 X3<int> x3i; // okay 85 86 X3<long> x3l; // expected-note {{in instantiation}} 87 } 88 89 // PR5716 90 namespace test4 { 91 template<typename> struct A { 92 template<typename T> friend void f(const A<T>&); 93 }; 94 95 template<typename T> void f(const A<T>&) { 96 int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}} 97 } 98 99 void f() { 100 f(A<int>()); // expected-note {{in instantiation of function template specialization}} 101 } 102 } 103 104 namespace test5 { 105 class outer { 106 class foo; 107 template <typename T> friend struct cache; 108 }; 109 class outer::foo { 110 template <typename T> friend struct cache; 111 }; 112 } 113 114 // PR6022 115 namespace PR6022 { 116 template <class T1, class T2 , class T3 > class A; 117 118 namespace inner { 119 template<class T1, class T2, class T3, class T> 120 A<T1, T2, T3>& f0(A<T1, T2, T3>&, T); 121 } 122 123 template<class T1, class T2, class T3> 124 class A { 125 template<class U1, class U2, class U3, class T> 126 friend A<U1, U2, U3>& inner::f0(A<U1, U2, U3>&, T); 127 }; 128 } 129 130 namespace FriendTemplateDefinition { 131 template<unsigned > struct int_c { }; 132 133 template<typename T> 134 struct X { 135 template<unsigned N> 136 friend void f(X, int_c<N>) { 137 int value = N; 138 }; 139 }; 140 141 void test_X(X<int> x, int_c<5> i5) { 142 f(x, i5); 143 } 144 } 145 146 namespace PR7013a { 147 template<class > struct X0 148 { 149 typedef int type; 150 }; 151 template<typename > struct X1 152 { 153 }; 154 template<typename , typename T> struct X2 155 { 156 typename T::type e; 157 }; 158 namespace N 159 { 160 template <typename = int, typename = X1<int> > struct X3 161 { 162 template <typename T1, typename T2, typename B> friend void op(X2<T1, T2>& , B); 163 }; 164 template <typename Ch, typename Tr, typename B> void op(X2<Ch, Tr>& , B) 165 { 166 X2<int, Tr> s; 167 } 168 } 169 int n() 170 { 171 X2<int, X0<int> > ngs; 172 N::X3<> b; 173 op(ngs, b); 174 return 0; 175 } 176 } 177 178 namespace PR7013b { 179 template<class > struct X0 180 { 181 typedef int type; 182 }; 183 template<typename > struct X1 184 { 185 }; 186 template<typename , typename T> struct X2 187 { 188 typename T::type e; 189 }; 190 namespace N 191 { 192 template <typename = X1<int> > struct X3 193 { 194 template <typename T1, typename T2, typename B> friend void op(X2<T1, T2>& , B); 195 }; 196 template <typename Ch, typename Tr, typename B> void op(X2<Ch, Tr>& , B) 197 { 198 X2<int, Tr> s; 199 } 200 } 201 int n() 202 { 203 X2<int, X0<int> > ngs; 204 N::X3<> b; 205 op(ngs, b); 206 return 0; 207 } 208 209 } 210 211 namespace PR8649 { 212 template<typename T, typename U, unsigned N> 213 struct X { 214 template<unsigned M> friend class X<T, U, M>; // expected-error{{partial specialization cannot be declared as a friend}} 215 }; 216 217 X<int, float, 7> x; 218 } 219 220 // Don't crash, and error on invalid friend type template. 221 namespace friend_type_template_no_tag { 222 template <typename T> struct S { 223 template <typename U> friend S<U>; // expected-error{{friend type templates must use an elaborated type}} 224 }; 225 template struct S<int>; 226 } 227 228 namespace PR10660 { 229 struct A { 230 template <> friend class B; // expected-error{{extraneous 'template<>' in declaration of class 'B'}} 231 }; 232 } 233 234 namespace rdar11147355 { 235 template <class T> 236 struct A { 237 template <class U> class B; 238 template <class S> template <class U> friend class A<S>::B; 239 }; 240 241 template <class S> template <class U> class A<S>::B { 242 }; 243 244 A<double>::B<double> ab; 245 } 246 247 namespace RedeclUnrelated { 248 struct S { 249 int packaged_task; 250 template<typename> class future { 251 template<typename> friend class packaged_task; 252 }; 253 future<void> share; 254 }; 255 } 256 257 namespace PR12557 { 258 template <typename> 259 struct Foo; 260 261 template <typename Foo_> 262 struct Bar { 263 typedef Foo_ Foo; // expected-note {{previous}} 264 265 template <typename> friend struct Foo; // expected-error {{redefinition of 'Foo' as different kind of symbol}} 266 }; 267 268 Bar<int> b; 269 } 270 271 namespace PR12585 { 272 struct A { }; 273 template<typename> struct B { 274 template<typename> friend class A::does_not_exist; // \ 275 // expected-error {{friend declaration of 'does_not_exist' does not match any declaration in 'PR12585::A'}} 276 }; 277 278 struct C { 279 template<typename> struct D; 280 }; 281 template<typename> class E { 282 int n; 283 template<typename> friend struct C::D; 284 }; 285 template<typename T> struct C::D { 286 int f() { 287 return E<int>().n; 288 } 289 }; 290 int n = C::D<void*>().f(); 291 292 struct F { 293 template<int> struct G; 294 }; 295 template<typename T> struct H { 296 // FIXME: As with cases above, the note here is on an unhelpful declaration, 297 // and should point to the declaration of G within F. 298 template<T> friend struct F::G; // \ 299 // expected-error {{different type 'char' in template redeclaration}} \ 300 // expected-note {{previous}} 301 }; 302 H<int> h1; // ok 303 H<char> h2; // expected-note {{instantiation}} 304 } 305 306 // Ensure that we can still instantiate a friend function template 307 // after the friend declaration is instantiated during the delayed 308 // parsing of a member function, but before the friend function has 309 // been parsed. 310 namespace rdar12350696 { 311 template <class T> struct A { 312 void foo() { 313 A<int> a; 314 } 315 template <class U> friend void foo(const A<U> & a) { 316 int array[sizeof(T) == sizeof(U) ? -1 : 1]; // expected-error {{negative size}} 317 } 318 }; 319 320 void test() { 321 A<int> b; 322 foo(b); // expected-note {{in instantiation}} 323 } 324 } 325
