clang/test/CXX/temp/temp.spec/temp.expl.spec/p2.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   4
   5
   6 // This test creates cases where implicit instantiations of various entities
   7 // would cause a diagnostic, but provides expliict specializations for those
   8 // entities that avoid the diagnostic. The specializations are alternately
   9 // declarations and definitions, and the intent of this test is to verify
  10 // that we allow specializations only in the appropriate namespaces (and
  11 // nowhere else).
  12 struct NonDefaultConstructible {
  13   NonDefaultConstructible(int);
  14 };
  15
  16
  17 // C++ [temp.expl.spec]p1:
  18 //   An explicit specialization of any of the following:
  19
  20 //     -- function template
  21 namespace N0 {
  22   template<typename T> void f0(T) {
  23     T t;
  24   }
  25
  26   template<> void f0(NonDefaultConstructible) { }
  27
  28   void test_f0(NonDefaultConstructible NDC) {
  29     f0(NDC);
  30   }
  31
  32   template<> void f0(int);
  33   template<> void f0(long);
  34 }
  35
  36 template<> void N0::f0(int) { } // okay
  37
  38 namespace N1 {
  39   template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
  40 }
  41
  42 template<> void N0::f0(double);
  43
  44 template<> void N0::f0(double) { }
  45
  46 struct X1 {
  47   template<typename T> void f(T);
  48
  49   template<> void f(int);
  50 };
  51
  52 //     -- class template
  53 namespace N0 {
  54
  55 template<typename T>
  56 struct X0 { // expected-note {{explicitly specialized declaration is here}}
  57   static T member;
  58
  59   void f1(T t) {
  60     t = 17;
  61   }
  62
  63   struct Inner : public T { }; // expected-note 2{{explicitly specialized declaration is here}}
  64
  65   template<typename U>
  66   struct InnerTemplate : public T { }; // expected-note {{explicitly specialized declaration is here}}
  67   // expected-error@-1 {{base specifier must name a class}}
  68
  69   template<typename U>
  70   void ft1(T t, U u);
  71 };
  72
  73 }
  74
  75 template<typename T>
  76 template<typename U>
  77 void N0::X0<T>::ft1(T t, U u) {
  78   t = u;
  79 }
  80
  81 template<typename T> T N0::X0<T>::member;
  82
  83 template<> struct N0::X0<void> { };
  84 N0::X0<void> test_X0;
  85
  86 namespace N1 {
  87   template<> struct N0::X0<const void> { }; // expected-error{{not in a namespace enclosing 'N0'}}
  88 }
  89
  90 namespace N0 {
  91   template<> struct X0<volatile void>;
  92 }
  93
  94 template<> struct N0::X0<volatile void> {
  95   void f1(void *);
  96 };
  97
  98 //     -- member function of a class template
  99 template<> void N0::X0<void*>::f1(void *) { }
 100
 101 void test_spec(N0::X0<void*> xvp, void *vp) {
 102   xvp.f1(vp);
 103 }
 104
 105 namespace N0 {
 106   template<> void X0<volatile void>::f1(void *) { } // expected-error{{no function template matches}}
 107
 108   template<> void X0<const volatile void*>::f1(const volatile void*);
 109 }
 110
 111 void test_x0_cvvoid(N0::X0<const volatile void*> x0, const volatile void *cvp) {
 112   x0.f1(cvp); // okay: we've explicitly specialized
 113 }
 114
 115 //     -- static data member of a class template
 116 namespace N0 {
 117   // This actually tests p15; the following is a declaration, not a definition.
 118   template<>
 119   NonDefaultConstructible X0<NonDefaultConstructible>::member;
 120
 121   template<> long X0<long>::member = 17;
 122
 123   template<> float X0<float>::member;
 124
 125   template<> double X0<double>::member;
 126 }
 127
 128 NonDefaultConstructible &get_static_member() {
 129   return N0::X0<NonDefaultConstructible>::member;
 130 }
 131
 132 template<> int N0::X0<int>::member;
 133
 134 template<> float N0::X0<float>::member = 3.14f;
 135
 136 namespace N1 {
 137   template<> double N0::X0<double>::member = 3.14; // expected-error{{does not enclose namespace}}
 138 }
 139
 140 //    -- member class of a class template
 141 namespace N0 {
 142
 143   template<>
 144   struct X0<void*>::Inner { };
 145
 146   template<>
 147   struct X0<int>::Inner { };
 148
 149   template<>
 150   struct X0<unsigned>::Inner;
 151
 152   template<>
 153   struct X0<float>::Inner;
 154
 155   template<>
 156   struct X0<double>::Inner; // expected-note{{forward declaration}}
 157 }
 158
 159 template<>
 160 struct N0::X0<long>::Inner { };
 161
 162 template<>
 163 struct N0::X0<float>::Inner { };
 164
 165 namespace N1 {
 166   template<>
 167   struct N0::X0<unsigned>::Inner { }; // expected-error{{member class specialization}}
 168
 169   template<>
 170   struct N0::X0<unsigned long>::Inner { }; // expected-error{{member class specialization}}
 171 };
 172
 173 N0::X0<void*>::Inner inner0;
 174 N0::X0<int>::Inner inner1;
 175 N0::X0<long>::Inner inner2;
 176 N0::X0<float>::Inner inner3;
 177 N0::X0<double>::Inner inner4; // expected-error{{incomplete}}
 178
 179 //    -- member class template of a class template
 180 namespace N0 {
 181   template<>
 182   template<>
 183   struct X0<void*>::InnerTemplate<int> { };
 184
 185   template<> template<>
 186   struct X0<int>::InnerTemplate<int>; // expected-note{{forward declaration}}
 187
 188   template<> template<>
 189   struct X0<int>::InnerTemplate<long>;
 190
 191   template<> template<>
 192   struct X0<int>::InnerTemplate<double>;
 193 }
 194
 195 template<> template<>
 196 struct N0::X0<int>::InnerTemplate<long> { }; // okay
 197
 198 template<> template<>
 199 struct N0::X0<int>::InnerTemplate<float> { };
 200
 201 namespace N1 {
 202   template<> template<>
 203   struct N0::X0<int>::InnerTemplate<double> { }; // expected-error{{enclosing}}
 204 }
 205
 206 N0::X0<void*>::InnerTemplate<int> inner_template0;
 207 N0::X0<int>::InnerTemplate<int> inner_template1; // expected-error{{incomplete}}
 208 N0::X0<int>::InnerTemplate<long> inner_template2;
 209 N0::X0<int>::InnerTemplate<unsigned long> inner_template3; // expected-note{{instantiation}}
 210
 211 //    -- member function template of a class template
 212 namespace N0 {
 213   template<>
 214   template<>
 215   void X0<void*>::ft1(void*, const void*) { }
 216
 217   template<> template<>
 218   void X0<void*>::ft1(void *, int);
 219
 220   template<> template<>
 221   void X0<void*>::ft1(void *, unsigned);
 222
 223   template<> template<>
 224   void X0<void*>::ft1(void *, long);
 225 }
 226
 227 template<> template<>
 228 void N0::X0<void*>::ft1(void *, unsigned) { } // okay
 229
 230 template<> template<>
 231 void N0::X0<void*>::ft1(void *, float) { }
 232
 233 namespace N1 {
 234   template<> template<>
 235   void N0::X0<void*>::ft1(void *, long) { } // expected-error{{does not enclose namespace}}
 236 }
 237
 238
 239 void test_func_template(N0::X0<void *> xvp, void *vp, const void *cvp,
 240                         int i, unsigned u) {
 241   xvp.ft1(vp, cvp);
 242   xvp.ft1(vp, i);
 243   xvp.ft1(vp, u);
 244 }
 245
 246 namespace PR8979 {
 247   template<typename Z>
 248   struct X0 {
 249     template <class T, class U> class Inner;
 250     struct OtherInner;
 251     template<typename T, typename U> void f(Inner<T, U>&);
 252
 253     typedef Inner<OtherInner, OtherInner> MyInner;
 254     template<> void f(MyInner&);
 255   };
 256 }