Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
      2 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
      3 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
      4 
      5 #define CONST const
      6 
      7 #ifdef PRECXX11
      8 #define static_assert(expr, msg) typedef int static_assert[(expr) ? 1 : -1];
      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;       // expected-error {{explicit specialization of 'right' in class scope}}
     19   template<> static CONST float right<float,int>;       // expected-error {{explicit specialization of 'right' in class scope}}
     20   template static CONST int right<int,int>;     // expected-error {{template specialization requires 'template<>'}} \
     21                                                 // expected-error {{explicit specialization of 'right' in class scope}}
     22 };
     23 
     24 namespace out_of_line {
     25   class B0 {
     26     template<typename T, typename T0> static CONST T right = T(100);
     27     template<typename T> static CONST T right<T,int> = T(5);
     28   };
     29   template<> CONST int B0::right<int,int> = 7;
     30   template CONST int B0::right<int,int>;
     31   template<> CONST int B0::right<int,float>;
     32   template CONST int B0::right<int,float>;
     33 
     34   class B1 {
     35     template<typename T, typename T0> static CONST T right;
     36     template<typename T> static CONST T right<T,int>;
     37   };
     38   template<typename T, typename T0> CONST T B1::right = T(100);
     39   template<typename T> CONST T B1::right<T,int> = T(5);
     40 
     41   class B2 {
     42     template<typename T, typename T0> static CONST T right = T(100);  // expected-note {{previous initialization is here}}
     43     template<typename T> static CONST T right<T,int> = T(5);          // expected-note {{previous initialization is here}}
     44   };
     45   template<typename T, typename T0> CONST T B2::right = T(100);   // expected-error {{static data member 'right' already has an initializer}}
     46   template<typename T> CONST T B2::right<T,int> = T(5);           // expected-error {{static data member 'right' already has an initializer}}
     47 
     48   class B3 {
     49     template<typename T, typename T0> static CONST T right = T(100);
     50     template<typename T> static CONST T right<T,int> = T(5);
     51   };
     52   template<typename T, typename T0> CONST T B3::right;
     53   template<typename T> CONST T B3::right<T,int>;
     54 
     55   class B4 {
     56     template<typename T, typename T0> static CONST T a;
     57     template<typename T> static CONST T a<T,int> = T(100);
     58     template<typename T, typename T0> static CONST T b = T(100);
     59     template<typename T> static CONST T b<T,int>;
     60   };
     61   template<typename T, typename T0> CONST T B4::a; // expected-error {{default initialization of an object of const type 'const int'}}
     62   template<typename T> CONST T B4::a<T,int>;
     63   template CONST int B4::a<int,char>; // expected-note {{in instantiation of}}
     64   template CONST int B4::a<int,int>;
     65 
     66   template<typename T, typename T0> CONST T B4::b;
     67   template<typename T> CONST T B4::b<T,int>; // expected-error {{default initialization of an object of const type 'const int'}}
     68   template CONST int B4::b<int,char>;
     69   template CONST int B4::b<int,int>; // expected-note {{in instantiation of}}
     70 }
     71 
     72 namespace non_const_init {
     73   class A {
     74     template<typename T> static T wrong_inst_undefined = T(10); // expected-note {{refers here}}
     75     template<typename T> static T wrong_inst_defined = T(10); // expected-error {{non-const static data member must be initialized out of line}}
     76     template<typename T> static T wrong_inst_out_of_line;
     77   };
     78 
     79   template const int A::wrong_inst_undefined<const int>; // expected-error {{undefined}}
     80 
     81   template<typename T> T A::wrong_inst_defined;
     82   template const int A::wrong_inst_defined<const int>;
     83   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}}
     84 
     85   template<typename T> T A::wrong_inst_out_of_line = T(10);
     86   template int A::wrong_inst_out_of_line<int>;
     87 
     88   class B {
     89     template<typename T> static T wrong_inst; // expected-note {{refers here}}
     90     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}}
     91 
     92     template<typename T> static T wrong_inst_fixed;
     93     template<typename T> static T wrong_inst_fixed<T*>;
     94   };
     95   template int B::wrong_inst<int>; // expected-error {{undefined}}
     96   // FIXME: It'd be better to produce the 'explicit instantiation of undefined
     97   // template' diagnostic here, not the 'must be initialized out of line'
     98   // diagnostic.
     99   template int B::wrong_inst<int*>; // expected-note {{in instantiation of static data member 'non_const_init::B::wrong_inst<int *>' requested here}}
    100   template const int B::wrong_inst<const int*>; // expected-error {{undefined}}
    101   template<typename T> T B::wrong_inst_fixed = T(100);
    102   template int B::wrong_inst_fixed<int>;
    103 
    104   class C {
    105     template<typename T> static CONST T right_inst = T(10); // expected-note {{here}}
    106     template<typename T> static CONST T right_inst<T*> = T(100); // expected-note {{here}}
    107   };
    108   template CONST int C::right_inst<int>; // expected-error {{undefined variable template}}
    109   template CONST int C::right_inst<int*>; // expected-error {{undefined variable template}}
    110 
    111   namespace pointers {
    112 
    113     struct C0 {
    114       template<typename U> static U Data;
    115       template<typename U> static CONST U Data<U*> = U(); // expected-note {{here}}
    116 
    117       template<typename U> static U Data2;
    118       template<typename U> static CONST U Data2<U*> = U();
    119     };
    120     const int c0_test = C0::Data<int*>;
    121     static_assert(c0_test == 0, "");
    122     template const int C0::Data<int*>; // expected-error {{undefined}}
    123 
    124     template<typename U> const U C0::Data2<U*>;
    125     template const int C0::Data2<int*>;
    126 
    127     struct C1a {
    128       template<typename U> static U Data;
    129       template<typename U> static U* Data<U*>;   // Okay, with out-of-line definition
    130     };
    131     template<typename T> T* C1a::Data<T*> = new T();
    132     template int* C1a::Data<int*>;
    133 
    134     struct C1b {
    135       template<typename U> static U Data;
    136       template<typename U> static CONST U* Data<U*>;   // Okay, with out-of-line definition
    137     };
    138     template<typename T> CONST T* C1b::Data<T*> = (T*)(0);
    139     template CONST int* C1b::Data<int*>;
    140 
    141     struct C2a {
    142       template<typename U> static int Data;
    143       template<typename U> static U* Data<U*> = new U();   // expected-error {{non-const static data member must be initialized out of line}}
    144     };
    145     template int* C2a::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2a::Data<int *>' requested here}}
    146 
    147     struct C2b {
    148       template<typename U> static int Data;
    149       template<typename U> static U *const Data<U*> = (U*)(0); // expected-error {{static data member of type 'int *const'}}
    150     };
    151     template<typename U> U *const C2b::Data<U*>;
    152     template int *const C2b::Data<int*>; // expected-note {{in instantiation of static data member 'non_const_init::pointers::C2b::Data<int *>' requested here}}
    153   }
    154 }
    155 
    156 #ifndef PRECXX11
    157 namespace constexpred {
    158   class A {
    159     template<typename T> constexpr T wrong;           // expected-error {{member 'wrong' declared as a template}} \
    160                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
    161     template<typename T> constexpr T wrong_init = 5;      // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
    162     template<typename T, typename T0> static constexpr T right = T(100);
    163     template<typename T> static constexpr T right<T,int> = 5;
    164     template<typename T> constexpr int right<int,T>;  // expected-error {{member 'right' declared as a template}} \
    165                                                       // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
    166     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?}}
    167     template<> static constexpr int right<int,int> = 7;       // expected-error {{explicit specialization of 'right' in class scope}}
    168     template<> static constexpr float right<float,int>;       // expected-error {{explicit specialization of 'right' in class scope}}
    169     template static constexpr int right<int,int>;     // expected-error {{template specialization requires 'template<>'}} \
    170                                                   // expected-error {{explicit specialization of 'right' in class scope}}
    171   };
    172 }
    173 #endif
    174 
    175 namespace in_class_template {
    176 
    177   template<typename T>
    178   class D0 {
    179     template<typename U> static U Data; // expected-note {{here}}
    180     template<typename U> static CONST U Data<U*> = U();
    181   };
    182   template CONST int D0<float>::Data<int*>;
    183   template int D0<float>::Data<int>; // expected-error {{undefined}}
    184   template<typename T> template<typename U> const U D0<T>::Data<U*>;
    185 
    186   template<typename T>
    187   class D1 {
    188     template<typename U> static U Data;
    189     template<typename U> static U* Data<U*>;
    190   };
    191   template<typename T>
    192   template<typename U> U* D1<T>::Data<U*> = (U*)(0);
    193   template int* D1<float>::Data<int*>; // expected-note {{previous}}
    194   template int* D1<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
    195 
    196   template<typename T>
    197   class D2 {
    198     template<typename U> static U Data;
    199     template<typename U> static U* Data<U*>;
    200   };
    201   template<>
    202   template<typename U> U* D2<float>::Data<U*> = (U*)(0) + 1;
    203   template int* D2<float>::Data<int*>; // expected-note {{previous}}
    204   template int* D2<float>::Data<int*>; // expected-error {{duplicate explicit instantiation}}
    205 
    206   template<typename T>
    207   struct D3 {
    208     template<typename U> static CONST U Data = U(100); // expected-note {{here}}
    209   };
    210   static_assert(D3<float>::Data<int> == 100, "");
    211   template const char D3<float>::Data<char>; // expected-error {{undefined}}
    212 
    213   namespace bug_files {
    214     template<typename T>
    215     class D0a {
    216       template<typename U> static U Data;
    217       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
    218     };
    219     template<>
    220     template<typename U> U D0a<float>::Data<U*> = U(100);  // expected-error {{redefinition of 'Data'}}
    221 
    222     // FIXME: We should accept this, and the corresponding case for class
    223     // templates.
    224     //
    225     // [temp.class.spec.mfunc]/2: If the primary member template is explicitly
    226     // specialized for a given specialization of the enclosing class template,
    227     // the partial specializations of the member template are ignored
    228     template<typename T>
    229     class D1 {
    230       template<typename U> static U Data;
    231       template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous declaration is here}}
    232     };
    233     template<>
    234     template<typename U> U D1<float>::Data = U(10);
    235     template<>
    236     template<typename U> U D1<float>::Data<U*> = U(100);  // expected-error{{redefinition of 'Data'}}
    237   }
    238 
    239   namespace definition_after_outer_instantiation {
    240     template<typename A> struct S {
    241       template<typename B> static const int V1;
    242       template<typename B> static const int V2;
    243     };
    244     template struct S<int>;
    245     template<typename A> template<typename B> const int S<A>::V1 = 123;
    246     template<typename A> template<typename B> const int S<A>::V2<B*> = 456;
    247 
    248     static_assert(S<int>::V1<int> == 123, "");
    249 
    250     // FIXME: The first and third case below possibly should be accepted. We're
    251     // not picking up partial specializations added after the primary template
    252     // is instantiated. This is kind of implied by [temp.class.spec.mfunc]/2,
    253     // and matches our behavior for member class templates, but it's not clear
    254     // that this is intentional. See PR17294 and core-24030.
    255     static_assert(S<int>::V2<int*> == 456, ""); // FIXME expected-error {{}}
    256     static_assert(S<int>::V2<int&> == 789, ""); // expected-error {{}}
    257 
    258     template<typename A> template<typename B> const int S<A>::V2<B&> = 789;
    259     static_assert(S<int>::V2<int&> == 789, ""); // FIXME expected-error {{}}
    260 
    261     // All is OK if the partial specialization is declared before the implicit
    262     // instantiation of the class template specialization.
    263     static_assert(S<char>::V1<int> == 123, "");
    264     static_assert(S<char>::V2<int*> == 456, "");
    265     static_assert(S<char>::V2<int&> == 789, "");
    266   }
    267 
    268   namespace incomplete_array {
    269     template<typename T> extern T var[];
    270     template<typename T> T var[] = { 1, 2, 3 };
    271     template<> char var<char>[] = "hello";
    272     template<typename T> char var<T*>[] = "pointer";
    273 
    274     static_assert(sizeof(var<int>) == 12, "");
    275     static_assert(sizeof(var<char>) == 6, "");
    276     static_assert(sizeof(var<void*>) == 8, "");
    277 
    278     template<typename...> struct tuple;
    279 
    280     template<typename T> struct A {
    281       template<typename U> static T x[];
    282       template<typename U> static T y[];
    283 
    284       template<typename...U> static T y<tuple<U...> >[];
    285     };
    286 
    287     int *use_before_definition = A<int>::x<char>;
    288     template<typename T> template<typename U> T A<T>::x[sizeof(U)];
    289     static_assert(sizeof(A<int>::x<char>) == 4, "");
    290 
    291     template<typename T> template<typename...U> T A<T>::y<tuple<U...> >[] = { U()... };
    292     static_assert(sizeof(A<int>::y<tuple<char, char, char> >) == 12, "");
    293   }
    294 
    295   namespace bad_reference {
    296     struct S {
    297       template<typename T> static int A; // expected-note 4{{here}}
    298     };
    299 
    300     template<typename T> void f() {
    301       typename T::template A<int> a; // expected-error {{template name refers to non-type template 'S::A'}}
    302     }
    303     template<typename T> void g() {
    304       T::template A<int>::B = 0; // expected-error {{template name refers to non-type template 'S::A'}}
    305     }
    306     template<typename T> void h() {
    307       class T::template A<int> c; // expected-error {{template name refers to non-type template 'S::A'}}
    308     }
    309 
    310     template<typename T>
    311     struct X : T::template A<int> {}; // expected-error {{template name refers to non-type template 'S::A'}}
    312 
    313     template void f<S>(); // expected-note {{in instantiation of}}
    314     template void g<S>(); // expected-note {{in instantiation of}}
    315     template void h<S>(); // expected-note {{in instantiation of}}
    316     template struct X<S>; // expected-note {{in instantiation of}}
    317   }
    318 }
    319 
    320 namespace in_nested_classes {
    321   // TODO:
    322 }
    323 
    324 namespace bitfield {
    325 struct S {
    326   template <int I>
    327   static int f : I; // expected-error {{static member 'f' cannot be a bit-field}}
    328 };
    329 }
    330 
    331 namespace b20896909 {
    332   // This used to crash.
    333   template<typename T> struct helper {};
    334   template<typename T> class A {
    335     template <typename> static helper<typename T::error> x;  // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
    336   };
    337   void test() {
    338     A<int> ai;  // expected-note {{in instantiation of}}
    339   }
    340 }
    341