test/SemaTemplate/friend-template.cpp

   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; // expected-warning {{dependent nested name specifier 'A<S>::' for friend template declaration is not supported; ignoring this friend declaration}}
 239   private:
 240     int n; // expected-note {{here}}
 241   };
 242
 243   template <class S> template <class U> class A<S>::B {
 244   public:
 245     // FIXME: This should be permitted.
 246     int f(A<S*> a) { return a.n; } // expected-error {{private}}
 247   };
 248
 249   A<double>::B<double>  ab;
 250   A<double*> a;
 251   int k = ab.f(a); // expected-note {{instantiation of}}
 252 }
 253
 254 namespace RedeclUnrelated {
 255   struct S {
 256     int packaged_task;
 257     template<typename> class future {
 258       template<typename> friend class packaged_task;
 259     };
 260     future<void> share;
 261   };
 262 }
 263
 264 namespace PR12557 {
 265   template <typename>
 266   struct Foo;
 267
 268   template <typename Foo_>
 269   struct Bar {
 270     typedef Foo_  Foo; // expected-note {{previous}}
 271
 272     template <typename> friend struct Foo; // expected-error {{redefinition of 'Foo' as different kind of symbol}}
 273   };
 274
 275   Bar<int> b;
 276 }
 277
 278 namespace PR12585 {
 279   struct A { };
 280   template<typename> struct B {
 281     template<typename> friend class A::does_not_exist; // \
 282      // expected-error {{friend declaration of 'does_not_exist' does not match any declaration in 'PR12585::A'}}
 283   };
 284
 285   struct C {
 286     template<typename> struct D;
 287   };
 288   template<typename> class E {
 289     int n;
 290     template<typename> friend struct C::D;
 291   };
 292   template<typename T> struct C::D {
 293     int f() {
 294       return E<int>().n;
 295     }
 296   };
 297   int n = C::D<void*>().f();
 298
 299   struct F {
 300     template<int> struct G;
 301   };
 302   template<typename T> struct H {
 303     // FIXME: As with cases above, the note here is on an unhelpful declaration,
 304     // and should point to the declaration of G within F.
 305     template<T> friend struct F::G; // \
 306       // expected-error {{different type 'char' in template redeclaration}} \
 307       // expected-note {{previous}}
 308   };
 309   H<int> h1; // ok
 310   H<char> h2; // expected-note {{instantiation}}
 311 }
 312
 313 // Ensure that we can still instantiate a friend function template
 314 // after the friend declaration is instantiated during the delayed
 315 // parsing of a member function, but before the friend function has
 316 // been parsed.
 317 namespace rdar12350696 {
 318   template <class T> struct A {
 319     void foo() {
 320       A<int> a;
 321     }
 322     template <class U> friend void foo(const A<U> & a) {
 323       int array[sizeof(T) == sizeof(U) ? -1 : 1]; // expected-error {{negative size}}
 324     }
 325   };
 326
 327   void test() {
 328     A<int> b;
 329     foo(b); // expected-note {{in instantiation}}
 330   }
 331 }