clang/test/ASTMerge/class-template-partial-spec/Inputs/class-template-partial-spec1.cpp

   1 template<typename T, class P>
   2 struct TwoOptionTemplate {};
   3
   4 template<typename T>
   5 struct TwoOptionTemplate<T, char> {
   6   int member;
   7 };
   8
   9
  10 template<typename T>
  11 struct TwoOptionTemplate<T, double> {
  12   float member;
  13 };
  14
  15 template<typename T>
  16 struct TwoOptionTemplate<T, T> {
  17   T** member;
  18 };
  19
  20 TwoOptionTemplate<int, char> X0;
  21 TwoOptionTemplate<int, float> X1;
  22 TwoOptionTemplate<void *, wchar_t> X2;
  23 TwoOptionTemplate<long, long> X3;
  24 TwoOptionTemplate<float, float> X4;
  25 TwoOptionTemplate<long, long> SingleSource;
  26 TwoOptionTemplate<char, double> SecondDoubleSource;
  27
  28
  29 template<int I, class C>
  30 struct IntTemplateSpec {};
  31
  32 template<class C>
  33 struct IntTemplateSpec<4, C> {
  34   C member;
  35 };
  36
  37 template<int I>
  38 struct IntTemplateSpec<I, void *> {
  39   int member;
  40   static constexpr int val = I;
  41 };
  42
  43 template<int I>
  44 struct IntTemplateSpec<I, double> {
  45   char member;
  46   static constexpr int val = I;
  47 };
  48
  49 IntTemplateSpec<4, wchar_t> Y0;
  50 IntTemplateSpec<5, void *> Y1;
  51 IntTemplateSpec<1, long> Y2;
  52 IntTemplateSpec<3, int> Y3;
  53 //template<int I> constexpr int IntTemplateSpec<I, double>::val;
  54 IntTemplateSpec<42, double> NumberSource;
  55 static_assert(NumberSource.val == 42);
  56
  57 namespace One {
  58 namespace Two {
  59   // Just an empty namespace to ensure we can deal with multiple namespace decls.
  60 }
  61 }
  62
  63
  64 namespace One {
  65 namespace Two {
  66 namespace Three {
  67
  68 template<class T>
  69 class Parent {};
  70
  71 } // namespace Three
  72
  73 } // namespace Two
  74
  75 template<typename T, typename X>
  76 struct Child1: public Two::Three::Parent<unsigned> {
  77   char member;
  78 };
  79
  80 template<class T>
  81 struct Child1<T, One::Two::Three::Parent<T>> {
  82   T member;
  83 };
  84
  85 } // namespace One
  86
  87 One::Child1<int, double> Z0Source;
  88
  89 // Test import of nested namespace specifiers
  90 template<typename T>
  91 struct Outer {
  92   template<typename U> class Inner0;
  93 };
  94
  95 template<typename X>
  96 template<typename Y>
  97 class Outer<X>::Inner0 {
  98 public:
  99   void f(X, Y);
 100   template<typename Z> struct Inner1;
 101 };
 102
 103 template<typename X>
 104 template<typename Y>
 105 void Outer<X>::Inner0<Y>::f(X, Y) {}
 106
 107 template<typename X>
 108 template<typename Y>
 109 template<typename Z>
 110 class Outer<X>::Inner0<Y>::Inner1 {
 111 public:
 112   void f(Y, Z);
 113 };
 114
 115 template<typename X>
 116 template<typename Y>
 117 template<typename Z>
 118 void Outer<X>::Inner0<Y>::Inner1<Z>::f(Y, Z) {}