test/SemaTemplate/temp_explicit.cpp

   1 // RUN: clang-cc -fsyntax-only -pedantic -verify %s
   2 //
   3 // Tests explicit instantiation of templates.
   4 template<typename T, typename U = T> class X0 { };
   5
   6 namespace N {
   7   template<typename T, typename U = T> class X1 { };
   8 }
   9
  10 // Check the syntax of explicit instantiations.
  11 template class X0<int, float>;
  12 template class X0<int>; // expected-note{{previous}}
  13
  14 template class N::X1<int>;
  15 template class ::N::X1<int, float>;
  16
  17 using namespace N;
  18 template class X1<float>;
  19
  20 // Check for some bogus syntax that probably means that the user
  21 // wanted to write an explicit specialization, but forgot the '<>'
  22 // after 'template'.
  23 template class X0<double> { }; // expected-error{{explicit specialization}}
  24
  25 // Check for explicit instantiations that come after other kinds of
  26 // instantiations or declarations.
  27 template class X0<int, int>; // expected-error{{duplicate}}
  28
  29 template<> class X0<char> { }; // expected-note{{previous}}
  30 template class X0<char>; // expected-warning{{ignored}}
  31
  32 void foo(X0<short>) { }
  33 template class X0<short>;
  34
  35 // Check that explicit instantiations actually produce definitions. We
  36 // determine whether this happens by placing semantic errors in the
  37 // definition of the template we're instantiating.
  38 template<typename T> struct X2; // expected-note{{declared here}}
  39
  40 template struct X2<float>; // expected-error{{undefined template}}
  41
  42 template<typename T>
  43 struct X2 {
  44   void f0(T*); // expected-error{{pointer to a reference}}
  45 };
  46
  47 template struct X2<int>; // okay
  48 template struct X2<int&>; // expected-note{{in instantiation of}}
  49
  50 // Check that explicit instantiations instantiate member classes.
  51 template<typename T> struct X3 {
  52   struct Inner {
  53     void f(T*); // expected-error{{pointer to a reference}}
  54   };
  55 };
  56
  57 void f1(X3<int&>); // okay, Inner, not instantiated
  58
  59 template struct X3<int&>; // expected-note{{instantiation}}
  60
  61 template<typename T> struct X4 {
  62   struct Inner {
  63     struct VeryInner {
  64       void f(T*); // expected-error 2{{pointer to a reference}}
  65     };
  66   };
  67 };
  68
  69 void f2(X4<int&>); // okay, Inner, not instantiated
  70 void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated
  71
  72 template struct X4<int&>; // expected-note{{instantiation}}
  73 template struct X4<float&>; // expected-note{{instantiation}}
  74
  75 // Check explicit instantiation of member classes
  76 namespace N2 {
  77
  78 template<typename T>
  79 struct X5 {
  80   struct Inner1 {
  81     void f(T&);
  82   };
  83
  84   struct Inner2 {
  85     struct VeryInner {
  86       void g(T*); // expected-error 2{{pointer to a reference}}
  87     };
  88   };
  89 };
  90
  91 }
  92
  93 template struct N2::X5<void>::Inner2;
  94
  95 using namespace N2;
  96 template struct X5<int&>::Inner2; // expected-note{{instantiation}}
  97
  98 void f4(X5<float&>::Inner2);
  99 template struct X5<float&>::Inner2; // expected-note{{instantiation}}
 100
 101 namespace N3 {
 102   template struct N2::X5<int>::Inner2;
 103 }
 104
 105 struct X6 {
 106   struct Inner { // expected-note{{here}}
 107     void f();
 108   };
 109 };
 110
 111 template struct X6::Inner; // expected-error{{non-templated}}