test/SemaTemplate/temp_explicit.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
   4 //
   5 // Tests explicit instantiation of templates.
   6 template<typename T, typename U = T> class X0 { };
   7
   8 namespace N {
   9   template<typename T, typename U = T> class X1 { };
  10 }
  11
  12 // Check the syntax of explicit instantiations.
  13 template class X0<int, float>;
  14 template class X0<int>; // expected-note{{previous}}
  15
  16 template class N::X1<int>;
  17 template class ::N::X1<int, float>;
  18
  19 using namespace N;
  20
  21 // Check for some bogus syntax that probably means that the user
  22 // wanted to write an explicit specialization, but forgot the '<>'
  23 // after 'template'.
  24 template class X0<double> { }; // expected-error{{explicit specialization}}
  25
  26 // Check for explicit instantiations that come after other kinds of
  27 // instantiations or declarations.
  28 template class X0<int, int>; // expected-error{{duplicate}}
  29
  30 template<> class X0<char> { }; // expected-note{{previous}}
  31 template class X0<char>; // expected-warning{{has no effect}}
  32
  33 void foo(X0<short>) { }
  34 template class X0<short>;
  35
  36 // Check that explicit instantiations actually produce definitions. We
  37 // determine whether this happens by placing semantic errors in the
  38 // definition of the template we're instantiating.
  39 template<typename T> struct X2; // expected-note{{declared here}}
  40
  41 template struct X2<float>; // expected-error{{undefined template}}
  42
  43 template<typename T>
  44 struct X2 {
  45   void f0(T*); // expected-error{{pointer to a reference}}
  46 };
  47
  48 template struct X2<int>; // okay
  49 template struct X2<int&>; // expected-note{{in instantiation of}}
  50
  51 // Check that explicit instantiations instantiate member classes.
  52 template<typename T> struct X3 {
  53   struct Inner {
  54     void f(T*); // expected-error{{pointer to a reference}}
  55   };
  56 };
  57
  58 void f1(X3<int&>); // okay, Inner, not instantiated
  59
  60 template struct X3<int&>; // expected-note{{instantiation}}
  61
  62 template<typename T> struct X4 {
  63   struct Inner {
  64     struct VeryInner {
  65       void f(T*); // expected-error 2{{pointer to a reference}}
  66     };
  67   };
  68 };
  69
  70 void f2(X4<int&>); // okay, Inner, not instantiated
  71 void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated
  72
  73 template struct X4<int&>; // expected-note{{instantiation}}
  74 template struct X4<float&>; // expected-note{{instantiation}}
  75
  76 // Check explicit instantiation of member classes
  77 namespace N2 {
  78
  79 template<typename T>
  80 struct X5 {
  81   struct Inner1 {
  82     void f(T&);
  83   };
  84
  85   struct Inner2 { // expected-note {{here}}
  86     struct VeryInner {
  87       void g(T*); // expected-error 2{{pointer to a reference}}
  88     };
  89   };
  90 };
  91
  92 }
  93
  94 template struct N2::X5<void>::Inner2;
  95
  96 using namespace N2;
  97 template struct X5<int&>::Inner2; // expected-note{{instantiation}}
  98
  99 void f4(X5<float&>::Inner2);
 100 template struct X5<float&>::Inner2; // expected-note{{instantiation}}
 101
 102 namespace N3 {
 103   template struct N2::X5<int>::Inner2;
 104 #if __cplusplus <= 199711L
 105 // expected-warning@-2 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
 106 #else
 107 // expected-error@-4 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
 108 #endif
 109 }
 110
 111 struct X6 {
 112   struct Inner { // expected-note{{here}}
 113     void f();
 114   };
 115 };
 116
 117 template struct X6::Inner; // expected-error{{non-templated}}
 118
 119 // PR5559
 120 template <typename T>
 121 struct Foo;
 122
 123 template <>
 124 struct Foo<int> // expected-note{{header not required for explicitly-specialized}}
 125 {
 126     template <typename U>
 127     struct Bar
 128     {};
 129 };
 130
 131 template <> // expected-warning{{extraneous template parameter list}}
 132 template <>
 133 struct Foo<int>::Bar<void>
 134 {};
 135
 136 namespace N1 {
 137
 138   template<typename T> struct X7 { }; // expected-note{{here}}
 139
 140   namespace Inner {
 141     template<typename T> struct X8 { };
 142   }
 143
 144   template struct X7<int>;
 145   template struct Inner::X8<int>;
 146 }
 147
 148 template<typename T> struct X9 { }; // expected-note{{here}}
 149
 150 template struct ::N1::Inner::X8<float>;
 151
 152 namespace N2 {
 153   using namespace N1;
 154
 155   template struct X7<double>;
 156 #if __cplusplus <= 199711L
 157 // expected-warning@-2 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
 158 #else
 159 // expected-error@-4 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
 160 #endif
 161
 162   template struct X9<float>;
 163 #if __cplusplus <= 199711L
 164 // expected-warning@-2 {{explicit instantiation of 'X9' must occur at global scope}}
 165 #else
 166 // expected-error@-4 {{explicit instantiation of 'X9' must occur at global scope}}
 167 #endif
 168 }