clang/test/SemaCXX/cxx1y-variable-templates_in_class.cpp

   1 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
   2 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
   3 // RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1y -verify -fsyntax-only %s -DCPP1Y
   4
   5 #define CONST const
   6
   7 #ifdef PRECXX11
   8 #define static_assert _Static_assert
   9 #endif
  10
  11 class A {
  12   template<typename T> CONST T wrong;           // expected-error {{member 'wrong' declared as a template}}
  13   template<typename T> CONST T wrong_init = 5;      // expected-error {{member 'wrong_init' declared as a template}}
  14   template<typename T, typename T0> static CONST T right = T(100);
  15   template<typename T> static CONST T right<T,int> = 5;
  16   template<typename T> CONST int right<int,T>;  // expected-error {{member 'right' declared as a template}}
  17   template<typename T> CONST float right<float,T> = 5;  // expected-error {{member 'right' declared as a template}}
  18   template<> static CONST int right<int,int> = 7;
  19   template<> static CONST float right<float,int>;
  20   template static CONST int right<int,int>;     // expected-error {{expected '<' after 'template'}}
  21 };
  22
  23 namespace out_of_line {
  24   class B0 {
  25     template<typename T, typename T0> static CONST T right = T(100);
  26     template<typename T> static CONST T right<T,int> = T(5);
  27   };
  28   template<> CONST int B0::right<int,int> = 7; // expected-note {{previous}}
  29   template CONST int B0::right<int,int>; // expected-warning {{has no effect}}
  30   template<> CONST int B0::right<int,float>; // expected-note {{previous}}
  31   template CONST int B0::right<int,float>; // expected-warning {{has no effect}}
  32
  33   class B1 {
  34     template<typename T, typename T0> static CONST T right;
  35     template<typename T> static CONST T right<T,int>;
  36   };
  37   template<typename T, typename T0> CONST T B1::right = T(100);
  38   template<typename T> CONST T B1::right<T,int> = T(5);
  39
  40   class B2 {
  41     template<typename T, typename T0> static CONST T right = T(100);  // expected-note {{previous initialization is here}}
  42     template<typename T> static CONST T right<T,int> = T(5);          // expected-note {{previous initialization is here}}
  43   };
  44   template<typename T, typename T0> CONST T B2::right = T(100);   // expected-error {{static data member 'right' already has an initializer}}
  45   template<typename T> CONST T B2::right<T,int> = T(5);           // expected-error {{static data member 'right' already has an initializer}}
  46
  47   class B3 {
  48     template<typename T, typename T0> static CONST T right = T(100);
  49     template<typename T> static CONST T right<T,int> = T(5);
  50   };
  51   template<typename T, typename T0> CONST T B3::right;
  52   template<typename T> CONST T B3::right<T,int>;
  53
  54   class B4 {
  55     template<typename T, typename T0> static CONST T a;
  56     template<typename T> static CONST T a<T,int> = T(100);
  57     template<typename T, typename T0> static CONST T b = T(100);
  58     template<typename T> static CONST T b<T,int>;
  59   };
  60   template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}}
  61   template<typename T> CONST T B4::a<T,int>;
  62   template CONST int B4::a<int,char>; // expected-note {{in instantiation of}}
  63   template CONST int B4::a<int,int>;
  64
  65   template<typename T, typename T0> CONST T B4::b;
  66   template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}}
  67   template CONST int B4::b<int,char>;
  68   template CONST int B4::b<int,int>; // expected-note {{in instantiation of}}
  69 }
  70
  71 namespace non_const_init {
  72   class A {
  73     template<typename T> static T wrong_inst_undefined = T(10); // expected-note {{refers here}}
  74     template<typename T> static T wrong_inst_defined = T(10); // expected-error {{non-const static data member must be initialized out of line}}
  75     template<typename T> static T wrong_inst_out_of_line;
  76   };
  77
  78   template const int A::wrong_inst_undefined<const int>; // expected-error {{undefined}}
  79
  80   template<typename T> T A::wrong_inst_defined;
  81   template const int A::wrong_inst_defined<const int>;
  82   template int A::wrong_inst_defined<int>; // expected-note {{in instantiation of static data member 'non_const_init::A::wrong_inst_defined<int>' requested here}}
  83
  84   template<typename T> T A::wrong_inst_out_of_line = T(10);
  85   template int A::wrong_inst_out_of_line<int>;
  86
  87   class B {
  88     template<typename T> static T wrong_inst; // expected-note {{refers here}}
  89     template<typename T> static T wrong_inst<T*> = T(100); // expected-error {{non-const static data member must be initialized out of line}} expected-note {{refers here}}
  90
  91     template<typename T> static T wrong_inst_fixed;
  92     template<typename T> static T wrong_inst_fixed<T*>;
  93   };
  94   template int B::wrong_inst<int>; // expected-error {{undefined}}
  95   // FIXME: It'd be better to produce the 'explicit instantiation of undefined
  96   // template' diagnostic here, not the 'must be initialized out of line'
  97   // diagnostic.
  98   template int B::wrong_inst<int*>; // expected-note {{in instantiation of static data member 'non_const_init::B::wrong_inst<int *>' requested here}}
  99   template const int B::wrong_inst<const int*>; // expected-error {{undefined}}
 100   template<typename T> T B::wrong_inst_fixed = T(100);
 101   template int B::wrong_inst_fixed<int>;
 102
 103   class C {
 104     template<typename T> static CONST T right_inst = T(10); // expected-note {{here}}
 105     template<typename T> static CONST T right_inst<T*> = T(100); // expected-note {{here}}
 106   };
 107   template CONST int C::right_inst<int>; // expected-error {{undefined variable template}}
 108   template CONST int C::right_inst<int*>; // expected-error {{undefined variable template}}
 109
 110   namespace pointers {
 111
 112     struct C0 {
 113       template<typename U> static U Data;
 114       template<typename U> static CONST U Data<U*> = U(); // expected-note {{here}}
 115
 116       template<typename U> static U Data2;
 117       template<typename U> static CONST U Data2<U*> = U();
 118     };
 119     const int c0_test = C0::Data<int*>;
 120     static_assert(c0_test == 0, "");
 121     template const int C0::Data<int*>; // expected-error {{undefined}}
 122
 123     template<typename U> const U C0::Data2<U*>;
 124     template const int C0::Data2<int*>;
 125
 126     struct C1a {
 127       template<typename U> static U Data;
 128       template<typename U> static U* Data<U*>;   // Okay, with out-of-line definition
 129     };
 130     template<typename T> T* C1a::Data<T*> = new T();
 131     template int* C1a::Data<int*>;
 132
 133     struct C1b {
 134       template<typename U> static U Data;
 135       template<typename U> static CONST U* Data<U*>;   // Okay, with out-of-line definition
 136     };
 137     template<typename T> CONST T* C1b::Data<T*> = (T*)(0);
 138     template CONST int* C1b::Data<int*>;
 139
 140     struct C2a {
 141       template<typename U> static int Data;
 142       template<typename U> static U* Data<U*> = new U();   // expected-error {{non-const static data member must be initialized out of line}}
 143     };
 144     template int* C2a::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2a::Data<int *>' requested here}}
 145
 146     struct C2b {
 147       template<typename U> static int Data;
 148       template<typename U> static U *const Data<U*> = (U*)(0); // expected-error {{static data member of type 'int *const'}}
 149     };
 150     template<typename U> U *const C2b::Data<U*>;
 151     template int *const C2b::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2b::Data<int *>' requested here}}
 152   }
 153 }
 154
 155 #ifndef PRECXX11
 156 namespace constexpred {
 157   class A {
 158     template<typename T> constexpr T wrong;           // expected-error {{member 'wrong' declared as a template}} \
 159                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
 160     template<typename T> constexpr T wrong_init = 5;      // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
 161     template<typename T, typename T0> static constexpr T right = T(100);
 162     template<typename T> static constexpr T right<T,int> = 5;
 163     template<typename T> constexpr int right<int,T>;  // expected-error {{member 'right' declared as a template}} \
 164                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
 165     template<typename T> constexpr float right<float,T> = 5;  // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
 166     template<> static constexpr int right<int,int> = 7;
 167     template <> static constexpr float right<float, int>; // expected-error {{declaration of constexpr static data member 'right<float, int>' requires an initializer}}
 168     template static constexpr int right<int,int>;     // expected-error {{expected '<' after 'template'}}
 169   };
 170 }
 171 #endif
 172
 173 namespace in_class_template {
 174
 175   template<typename T>
 176   class D0 {
 177     template<typename U> static U Data; // expected-note {{here}}
 178     template<typename U> static CONST U Data<U*> = U();
 179   };
 180   template CONST int D0<float>::Data<int*>;
 181   template int D0<float>::Data<int>; // expected-error {{undefined}}
 182   template<typename T> template<typename U> const U D0<T>::Data<U*>;
 183
 184   template<typename T>
 185   class D1 {
 186     template<typename U> static U Data;
 187     template<typename U> static U* Data<U*>;
 188   };
 189   template<typename T>
 190   template<typename U> U* D1<T>::Data<U*> = (U*)(0);
 191   template int* D1<float>::Data<int*>; // expected-note {{previous}}
 192   template int* D1<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
 193
 194   template<typename T>
 195   class D2 {
 196     template<typename U> static U Data;
 197     template<typename U> static U* Data<U*>;
 198   };
 199   template<>
 200   template<typename U> U* D2<float>::Data<U*> = (U*)(0) + 1;
 201   template int* D2<float>::Data<int*>; // expected-note {{previous}}
 202   template int* D2<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
 203
 204   template<typename T>
 205   struct D3 {
 206     template<typename U> static CONST U Data = U(100); // expected-note {{here}}
 207   };
 208   static_assert(D3<float>::Data<int> == 100, "");
 209   template const char D3<float>::Data<char>; // expected-error {{undefined}}
 210
 211   namespace bug_files {
 212     template<typename T>
 213     class D0a {
 214       template<typename U> static U Data;
 215       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
 216     };
 217     template<>
 218     template<typename U> U D0a<float>::Data<U*> = U(100);  // expected-error {{redefinition of 'Data'}}
 219
 220     // FIXME: We should accept this, and the corresponding case for class
 221     // templates.
 222     //
 223     // [temp.class.spec.mfunc]/2: If the primary member template is explicitly
 224     // specialized for a given specialization of the enclosing class template,
 225     // the partial specializations of the member template are ignored
 226     template<typename T>
 227     class D1 {
 228       template<typename U> static U Data;
 229       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
 230     };
 231     template<>
 232     template<typename U> U D1<float>::Data = U(10);
 233     template<>
 234     template<typename U> U D1<float>::Data<U*> = U(100);  // expected-error{{redefinition of 'Data'}}
 235   }
 236
 237   namespace definition_after_outer_instantiation {
 238     template<typename A> struct S {
 239       template<typename B> static const int V1;
 240       template<typename B> static const int V2; // expected-note 3{{here}}
 241     };
 242     template struct S<int>;
 243     template<typename A> template<typename B> const int S<A>::V1 = 123;
 244     template<typename A> template<typename B> const int S<A>::V2<B*> = 456;
 245
 246     static_assert(S<int>::V1<int> == 123, "");
 247
 248     // FIXME: The first and third case below possibly should be accepted. We're
 249     // not picking up partial specializations added after the primary template
 250     // is instantiated. This is kind of implied by [temp.class.spec.mfunc]/2,
 251     // and matches our behavior for member class templates, but it's not clear
 252     // that this is intentional. See PR17294 and core-24030.
 253     static_assert(S<int>::V2<int*> == 456, ""); // FIXME expected-error {{}} expected-note {{initializer of 'V2<int *>' is unknown}}
 254     static_assert(S<int>::V2<int&> == 789, ""); // expected-error {{}} expected-note {{initializer of 'V2<int &>' is unknown}}
 255
 256     template<typename A> template<typename B> const int S<A>::V2<B&> = 789;
 257     static_assert(S<int>::V2<int&> == 789, ""); // FIXME expected-error {{}} expected-note {{initializer of 'V2<int &>' is unknown}}
 258
 259     // All is OK if the partial specialization is declared before the implicit
 260     // instantiation of the class template specialization.
 261     static_assert(S<char>::V1<int> == 123, "");
 262     static_assert(S<char>::V2<int*> == 456, "");
 263     static_assert(S<char>::V2<int&> == 789, "");
 264   }
 265
 266   namespace incomplete_array {
 267     template<typename T> extern T var[];
 268     template<typename T> T var[] = { 1, 2, 3 };
 269     template<> char var<char>[] = "hello";
 270     template<typename T> char var<T*>[] = "pointer";
 271
 272     static_assert(sizeof(var<int>) == 12, "");
 273     static_assert(sizeof(var<char>) == 6, "");
 274     static_assert(sizeof(var<void*>) == 8, "");
 275
 276     template<typename...> struct tuple;
 277
 278     template<typename T> struct A {
 279       template<typename U> static T x[];
 280       template<typename U> static T y[];
 281
 282       template<typename...U> static T y<tuple<U...> >[];
 283     };
 284
 285     int *use_before_definition = A<int>::x<char>;
 286     template<typename T> template<typename U> T A<T>::x[sizeof(U)];
 287     static_assert(sizeof(A<int>::x<char>) == 4, "");
 288
 289     template<typename T> template<typename...U> T A<T>::y<tuple<U...> >[] = { U()... };
 290     static_assert(sizeof(A<int>::y<tuple<char, char, char> >) == 12, "");
 291   }
 292
 293   namespace bad_reference {
 294     struct S {
 295       template<typename T> static int A; // expected-note 4{{here}}
 296     };
 297
 298     template<typename T> void f() {
 299       typename T::template A<int> a; // expected-error {{template name refers to non-type template 'S::template A'}}
 300     }
 301     template<typename T> void g() {
 302       T::template A<int>::B = 0; // expected-error {{template name refers to non-type template 'S::template A'}}
 303     }
 304     template<typename T> void h() {
 305       class T::template A<int> c; // expected-error {{template name refers to non-type template 'S::template A'}}
 306     }
 307
 308     template<typename T>
 309     struct X : T::template A<int> {}; // expected-error {{template name refers to non-type template 'S::template A'}}
 310
 311     template void f<S>(); // expected-note {{in instantiation of}}
 312     template void g<S>(); // expected-note {{in instantiation of}}
 313     template void h<S>(); // expected-note {{in instantiation of}}
 314     template struct X<S>; // expected-note {{in instantiation of}}
 315   }
 316 }
 317
 318 namespace in_nested_classes {
 319   // TODO:
 320 }
 321
 322 namespace bitfield {
 323 struct S {
 324   template <int I>
 325   static int f : I; // expected-error {{static member 'f' cannot be a bit-field}}
 326 };
 327 }
 328
 329 namespace b20896909 {
 330   // This used to crash.
 331   template<typename T> struct helper {};
 332   template<typename T> class A {
 333     template <typename> static helper<typename T::error> x;  // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
 334   };
 335   void test() {
 336     A<int> ai;  // expected-note {{in instantiation of}}
 337   }
 338 }
 339 namespace member_access_is_ok {
 340 #ifdef CPP1Y
 341   namespace ns1 {
 342     struct A {
 343       template<class T, T N> constexpr static T Var = N;
 344     };
 345     static_assert(A{}.Var<int,5> == 5,"");
 346   } // end ns1
 347 #endif // CPP1Y
 348
 349 namespace ns2 {
 350   template<class T> struct A {
 351     template<class U, T N, U M> static T&& Var;
 352   };
 353   template<class T> template<class U, T N, U M> T&& A<T>::Var = T(N + M);
 354   int *AV = &A<int>().Var<char, 5, 'A'>;
 355
 356 } //end ns2
 357 } // end ns member_access_is_ok
 358
 359 #ifdef CPP1Y
 360 namespace PR24473 {
 361 struct Value
 362 {
 363     template<class T>
 364     static constexpr T value = 0;
 365 };
 366
 367 template<typename TValue>
 368 struct Something
 369 {
 370     void foo() {
 371         static_assert(TValue::template value<int> == 0, ""); // error
 372     }
 373 };
 374
 375 int main() {
 376     Something<Value>{}.foo();
 377     return 0;
 378 }
 379
 380 } // end ns PR24473
 381 #endif // CPP1Y
 382
 383 namespace dependent_static_var_template {
 384   struct A {
 385     template<int = 0> static int n; // expected-note 2{{here}}
 386   };
 387   int &r = A::template n; // expected-error {{use of variable template 'n' requires template arguments}}
 388
 389   template<typename T>
 390   int &f() { return T::template n; } // expected-error {{use of variable template 'n' requires template arguments}}
 391   int &s = f<A>(); // expected-note {{instantiation of}}
 392
 393   namespace B {
 394     template<int = 0> static int n; // expected-note {{here}}
 395   }
 396   int &t = B::template n; // expected-error {{use of variable template 'n' requires template arguments}}
 397
 398   struct C {
 399     template <class T> static T G;
 400   };
 401   template<class T> T C::G = T(6);
 402
 403   template <class T> T F() {
 404     C c;
 405     return c.G<T>;
 406   }
 407
 408   int cf() { return F<int>(); }
 409 }
 410
 411 #ifndef PRECXX11
 412 namespace template_vars_in_template {
 413 template <int> struct TakesInt {};
 414
 415 template <class T2>
 416 struct S {
 417   template <class T1>
 418   static constexpr int v = 42;
 419
 420   template <class T>
 421   void mf() {
 422     constexpr int val = v<T>;
 423   }
 424
 425   void mf2() {
 426     constexpr int val = v<char>;
 427     TakesInt<val> ti;
 428     (void)ti.x; // expected-error{{no member named 'x' in 'template_vars_in_template::TakesInt<42>'}}
 429   }
 430 };
 431
 432 void useit() {
 433   S<int> x;
 434   x.mf<double>();
 435   x.mf2(); // expected-note{{in instantiation of member function 'template_vars_in_template::S<int>::mf2' requested here}}
 436 }
 437 }
 438 #endif